(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-106', 'single', plan, 'medium',
      t('A data engineering team needs to create and manage lakehouses in one workspace. Business analysts only need to view reports and semantic models in the same workspace.', 'Ein Data-Engineering-Team muss Lakehouses in einem Arbeitsbereich erstellen und verwalten. Fachanalysten müssen im selben Arbeitsbereich nur Berichte und semantische Modelle anzeigen.'),
      t('Which workspace role should you assign to the analysts to follow least-privilege access?', 'Welche Arbeitsbereichsrolle sollten Sie den Analysten nach dem Least-Privilege-Prinzip zuweisen?'),
      [
        o('A', 'Admin', 'Administrator'),
        o('B', 'Member', 'Mitglied'),
        o('C', 'Viewer', 'Betrachter'),
        o('D', 'Contributor', 'Mitwirkender')
      ],
      ['C'],
      t('Viewer is the least-privileged workspace role for users who only need to consume content. It allows read access without granting content creation or workspace management rights.', 'Betrachter ist die am wenigsten privilegierte Arbeitsbereichsrolle für Benutzer, die Inhalte nur konsumieren müssen. Sie erlaubt Lesezugriff, ohne Rechte zum Erstellen von Inhalten oder zum Verwalten des Arbeitsbereichs zu gewähren.'),
      t('Choose the role intended for consumption rather than editing.', 'Wählen Sie die Rolle, die für den Konsum und nicht für die Bearbeitung gedacht ist.'),
      ref.workspaces),

    q('dp700-107', 'multiple', plan, 'medium', null,
      t('Which two actions strengthen governance of self-service Fabric workspaces?', 'Welche zwei Maßnahmen stärken die Governance von Self-Service-Fabric-Arbeitsbereichen?'),
      [
        o('A', 'Delegate domain ownership to business data owners with clear boundaries', 'Delegieren Sie die Domänenverantwortung mit klaren Grenzen an fachliche Datenverantwortliche'),
        o('B', 'Allow all users unrestricted tenant settings changes', 'Erlauben Sie allen Benutzern uneingeschränkte Änderungen an Mandanteneinstellungen'),
        o('C', 'Use the admin center to control who can create workspaces and use specific features', 'Verwenden Sie das Admin Center, um zu steuern, wer Arbeitsbereiche erstellen und bestimmte Funktionen nutzen darf'),
        o('D', 'Make every workspace public to simplify discovery', 'Machen Sie jeden Arbeitsbereich öffentlich, um die Auffindbarkeit zu vereinfachen')
      ],
      ['A', 'C'],
      t('Domain delegation supports scalable ownership, while tenant settings in the admin center let central admins govern feature access. Unrestricted settings changes and public-by-default workspaces weaken governance.', 'Die Delegation von Domänen unterstützt skalierbare Verantwortung, während Mandanteneinstellungen im Admin Center zentralen Administratoren die Steuerung des Funktionszugriffs ermöglichen. Uneingeschränkte Einstellungsänderungen und standardmäßig öffentliche Arbeitsbereiche schwächen die Governance.'),
      t('Look for one central governance control and one delegated ownership control.', 'Suchen Sie nach einer zentralen Governance-Steuerung und einer delegierten Eigentümersteuerung.'),
      ref.admin),

    q('dp700-108', 'single', plan, 'hard',
      t('A Fabric capacity hosts report queries during the day and large notebook jobs every night. Morning users begin to see delayed interactive queries after several heavy overnight runs.', 'Eine Fabric-Kapazität hostet tagsüber Berichtsabfragen und jede Nacht große Notebook-Jobs. Benutzer am Morgen sehen nach mehreren schweren nächtlichen Läufen verzögerte interaktive Abfragen.'),
      t('What is the best explanation for this behavior?', 'Was ist die beste Erklärung für dieses Verhalten?'),
      [
        o('A', 'Background jobs are smoothed over time, and sustained overages can trigger throttling on the capacity', 'Hintergrundaufträge werden über die Zeit geglättet, und anhaltende Überlastungen können eine Drosselung auf der Kapazität auslösen'),
        o('B', 'Interactive report queries are always isolated from background jobs on the same capacity', 'Interaktive Berichtsabfragen sind auf derselben Kapazität immer von Hintergrundaufträgen isoliert'),
        o('C', 'Smoothing means notebook jobs consume no capacity units', 'Glättung bedeutet, dass Notebook-Jobs keine Kapazitätseinheiten verbrauchen'),
        o('D', 'Throttling can occur only in Power BI Embedded, not in Fabric capacities', 'Drosselung kann nur in Power BI Embedded auftreten, nicht in Fabric-Kapazitäten')
      ],
      ['A'],
      t('Fabric applies smoothing to capacity consumption, but sustained overages still accumulate. If the capacity remains overused, throttling can slow or delay subsequent operations, including interactive ones.', 'Fabric wendet eine Glättung auf den Kapazitätsverbrauch an, aber anhaltende Überlastungen summieren sich trotzdem. Wenn die Kapazität weiter überlastet bleibt, kann Drosselung nachfolgende Vorgänge verlangsamen oder verzögern, auch interaktive.'),
      t('Think about overages being accounted for over time rather than ignored.', 'Denken Sie daran, dass Überlastungen über die Zeit verbucht und nicht ignoriert werden.'),
      ref.smoothing),

    q('dp700-109', 'single', plan, 'medium',
      t('A business unit wants to analyze files already stored in Amazon S3 from Fabric, but legal policy does not allow copying the data into OneLake.', 'Eine Geschäftseinheit möchte bereits in Amazon S3 gespeicherte Dateien aus Fabric analysieren, aber die Rechtsabteilung erlaubt kein Kopieren der Daten nach OneLake.'),
      t('Which approach should you choose first?', 'Welchen Ansatz sollten Sie zuerst 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 data into a warehouse', 'Spiegeln Sie die S3-Daten in ein Warehouse'),
        o('C', 'Export the S3 files to CSV and upload them manually', 'Exportieren Sie die S3-Dateien nach CSV und laden Sie sie manuell hoch'),
        o('D', 'Build a semantic model directly against the S3 bucket without any Fabric item', 'Erstellen Sie ein semantisches Modell direkt gegen den S3-Bucket ohne Fabric-Element')
      ],
      ['A'],
      t('Shortcuts virtualize access to external data without copying it into OneLake storage. Mirroring is for supported source systems that replicate data into Fabric, which does not fit the no-copy requirement here.', 'Shortcuts virtualisieren den Zugriff auf externe Daten, ohne sie in den OneLake-Speicher zu kopieren. Mirroring ist für unterstützte Quellsysteme gedacht, die Daten nach Fabric replizieren, und passt daher nicht zur Anforderung ohne Kopie.'),
      t('The key requirement is access without duplication.', 'Die zentrale Anforderung ist Zugriff ohne Duplizierung.'),
      ref.shortcuts),

    q('dp700-110', 'multiple', plan, 'hard', null,
      t('Which two practices align best with implementing a data mesh in Microsoft Fabric?', 'Welche zwei Praktiken passen am besten zur Umsetzung eines Data Mesh 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 a single central team to publish every report and table for all domains', 'Verlangen Sie, dass ein einziges zentrales Team jeden Bericht und jede Tabelle für alle Domänen veröffentlicht'),
        o('C', 'Use endorsements and catalog discovery so consumers can find trusted domain data products', 'Verwenden Sie Endorsements und Katalogsuche, damit Verbraucher vertrauenswürdige Domänendatenprodukte finden können'),
        o('D', 'Prevent domains from owning their own semantic models', 'Verhindern Sie, dass Domänen ihre eigenen semantischen Modelle besitzen')
      ],
      ['A', 'C'],
      t('Fabric domains, workspaces, endorsements, and catalog capabilities support data mesh patterns where domains own and publish trusted data products. A purely centralized publishing model conflicts with domain-oriented ownership.', 'Fabric-Domänen, Arbeitsbereiche, Endorsements und Katalogfunktionen unterstützen Data-Mesh-Muster, bei denen Domänen vertrauenswürdige Datenprodukte selbst besitzen und veröffentlichen. Ein rein zentralisiertes Veröffentlichungsmodell steht dem domänenorientierten Besitz entgegen.'),
      t('Choose the answers that support domain ownership plus discoverability.', 'Wählen Sie die Antworten, die Domänenbesitz plus Auffindbarkeit unterstützen.'),
      ref.domains),

    q('dp700-111', 'single', plan, 'hard',
      t('Your team needs open Delta tables for Spark engineering, but the finance team also wants SQL access over the same curated data with minimal duplication.', 'Ihr Team benötigt offene Delta-Tabellen für Spark-Engineering, aber das Finanzteam möchte 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', 'Dashboard', 'Dashboard'),
        o('C', 'Dataflow Gen2', 'Dataflow Gen2'),
        o('D', 'KQL Queryset', 'KQL-Queryset')
      ],
      ['A'],
      t('A lakehouse stores Delta tables in OneLake and supports Spark workloads directly, while also exposing a SQL analytics endpoint for SQL users. This matches the requirement for shared open-format data with multiple consumption paths.', 'Ein Lakehouse speichert Delta-Tabellen in OneLake und unterstützt Spark-Workloads direkt, während es gleichzeitig einen SQL-Analyseendpunkt für SQL-Benutzer bereitstellt. Das entspricht der Anforderung nach gemeinsam genutzten Daten im offenen Format mit mehreren Nutzungspfaden.'),
      t('Think of one storage layer that serves both Spark and SQL.', 'Denken Sie an eine Speicherschicht, die sowohl Spark als auch SQL bedient.'),
      ref.lakehouse),

    q('dp700-112', 'single', plan, 'medium', null,
      t('Which admin-center concept lets tenant administrators control whether selected users or groups can use specific Fabric features?', 'Welches Konzept im Admin Center ermöglicht es Mandantenadministratoren zu steuern, ob ausgewählte Benutzer oder Gruppen bestimmte Fabric-Funktionen nutzen dürfen?'),
      [
        o('A', 'Tenant settings', 'Mandanteneinstellungen'),
        o('B', 'Drillthrough filters', 'Drillthrough-Filter'),
        o('C', 'DAX measures', 'DAX-Measures'),
        o('D', 'Shortcut paths', 'Shortcut-Pfade')
      ],
      ['A'],
      t('Tenant settings in the Fabric admin center are used to enable, disable, or scope features to parts of the organization. This is the central governance layer for feature availability.', 'Mandanteneinstellungen im Fabric Admin Center werden verwendet, um Funktionen zu aktivieren, zu deaktivieren oder auf Teile der Organisation zu beschränken. Dies ist die zentrale Governance-Ebene für die Verfügbarkeit von Funktionen.'),
      t('Look for the tenant-wide control surface.', 'Suchen Sie nach der mandantenweiten Steuerungsoberfläche.'),
      ref.admin),

    q('dp700-113', 'single', plan, 'medium',
      t('A capacity assigned to several workspaces shows regular slowdowns. You need evidence about which workloads and time periods are driving the pressure before resizing the SKU.', 'Eine mehreren Arbeitsbereichen zugewiesene Kapazität zeigt regelmäßige Verlangsamungen. Sie benötigen Belege dafür, welche Workloads und Zeiträume den Druck verursachen, bevor Sie die SKU anpassen.'),
      t('What should you do first?', 'Was sollten Sie zuerst tun?'),
      [
        o('A', 'Delete old workspaces immediately', 'Löschen Sie sofort alte Arbeitsbereiche'),
        o('B', 'Review capacity metrics and optimize workload placement', 'Prüfen Sie Kapazitätsmetriken und optimieren Sie die Platzierung der Workloads'),
        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')
      ],
      ['B'],
      t('Capacity optimization starts with evidence from metrics so you can identify which workloads, time windows, and workspaces are causing pressure. Resizing without understanding the pattern can waste capacity or miss the root cause.', 'Kapazitätsoptimierung beginnt mit Nachweisen aus Metriken, damit Sie erkennen können, welche Workloads, Zeitfenster und Arbeitsbereiche Druck verursachen. Eine Größenänderung ohne Verständnis des Musters kann Kapazität verschwenden oder die eigentliche Ursache verfehlen.'),
      t('Measure before you resize.', 'Messen Sie, bevor Sie die Größe ändern.'),
      ref.capacity),

    q('dp700-114', 'single', plan, 'medium',
      t('A finance report in a shared workspace contains sensitive results. One executive should see that report, but must not edit workspace content or browse engineering notebooks stored in the same workspace.', 'Ein Finanzbericht in einem gemeinsam genutzten Arbeitsbereich enthält sensible Ergebnisse. Eine Führungskraft soll diesen Bericht sehen können, darf aber weder Inhalte des Arbeitsbereichs bearbeiten noch Engineering-Notebooks im selben Arbeitsbereich durchsuchen.'),
      t('What is the best access design?', 'Was ist das beste Zugriffskonzept?'),
      [
        o('A', 'Grant the executive the Member role in the workspace', 'Geben Sie der Führungskraft die Rolle Mitglied im Arbeitsbereich'),
        o('B', 'Grant the executive the Admin role in the workspace', 'Geben Sie der Führungskraft 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 Bearbeitungszugriffs auf den Arbeitsbereich'),
        o('D', 'Move all notebooks to the recycle bin', 'Verschieben Sie alle Notebooks in den Papierkorb')
      ],
      ['C'],
      t('If a user only needs to consume a specific report, sharing the report or app is more precise than granting editing rights in the workspace. This follows least privilege and avoids unnecessary exposure to other items.', 'Wenn ein Benutzer nur einen bestimmten Bericht konsumieren muss, ist das Teilen des Berichts oder der App präziser als das Gewähren von Bearbeitungsrechten im Arbeitsbereich. Dies folgt dem Least-Privilege-Prinzip und vermeidet unnötige Einsicht in andere Elemente.'),
      t('Avoid broad edit rights when only report consumption is required.', 'Vermeiden Sie breite Bearbeitungsrechte, wenn nur die Nutzung eines Berichts erforderlich ist.'),
      ref.workspaces),

    q('dp700-115', 'single', plan, 'medium', null,
      t('Why would an organization use Fabric domains in addition to workspaces?', 'Warum würde eine Organisation Fabric-Domänen zusätzlich zu Arbeitsbereichen verwenden?'),
      [
        o('A', 'To replace Microsoft Entra ID groups entirely', 'Um Microsoft-Entra-ID-Gruppen vollständig zu ersetzen'),
        o('B', 'To organize and govern data assets logically by business area across workspaces', 'Um Datenbestände über Arbeitsbereiche hinweg logisch nach Geschäftsbereich zu organisieren und zu steuern'),
        o('C', 'To force every item into DirectQuery mode', 'Um jedes Element in den DirectQuery-Modus zu zwingen'),
        o('D', 'To convert KQL queries into DAX', 'Um KQL-Abfragen in DAX zu konvertieren')
      ],
      ['B'],
      t('Domains provide an organizational layer above individual workspaces so enterprises can group and govern content by business area. They help scale ownership, discovery, and governance in large Fabric estates.', 'Domänen stellen eine organisatorische Ebene über einzelnen Arbeitsbereichen bereit, sodass Unternehmen Inhalte nach Geschäftsbereich gruppieren und steuern können. Sie helfen dabei, Besitz, Auffindbarkeit und Governance in großen Fabric-Landschaften zu skalieren.'),
      t('Think about business-aligned organization across multiple workspaces.', 'Denken Sie an geschäftsorientierte Organisation über mehrere Arbeitsbereiche hinweg.'),
      ref.domains),

    q('dp700-116', 'single', plan, 'hard', null,
      t('Which statement best describes burstable behavior on an F SKU capacity?', 'Welche Aussage beschreibt das Burst-Verhalten einer F-SKU-Kapazität am besten?'),
      [
        o('A', 'Short bursts above baseline can be absorbed, but sustained overuse can still lead to throttling', 'Kurze Spitzen über dem Basiswert können aufgefangen werden, aber anhaltende Übernutzung kann trotzdem zu Drosselung führen'),
        o('B', 'Bursting means the SKU has unlimited compute for all workloads', 'Bursting bedeutet, dass die SKU unbegrenzte Rechenleistung für alle Workloads hat'),
        o('C', 'Bursting applies only to report visuals and never to data engineering operations', 'Bursting gilt nur für Berichtsvisuals und niemals für Data-Engineering-Vorgänge'),
        o('D', 'Bursting permanently increases the purchased CU baseline', 'Bursting erhöht dauerhaft die gekaufte CU-Basis')
      ],
      ['A'],
      t('Bursting can absorb short periods of higher activity, but it does not remove the long-term limits of the purchased SKU. If overages continue, the capacity can still throttle workloads.', 'Bursting kann kurze Phasen höherer Aktivität auffangen, hebt aber die langfristigen Grenzen der gekauften SKU nicht auf. Wenn Überlastungen andauern, kann die Kapazität Workloads weiterhin drosseln.'),
      t('Temporary headroom is not the same as unlimited capacity.', 'Temporärer Spielraum ist nicht dasselbe wie unbegrenzte Kapazität.'),
      ref.capacity),

    q('dp700-117', 'single', plan, 'hard',
      t('A team wants near real-time analytics on Azure SQL operational tables inside Fabric. They want the data replicated into OneLake so downstream workloads can query local copies with low latency.', 'Ein Team möchte nahezu in Echtzeit Analysen auf operativen Azure-SQL-Tabellen in Fabric durchführen. Die Daten sollen nach OneLake repliziert werden, damit nachgelagerte Workloads lokale Kopien mit geringer Latenz 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 paginated report on the source database', 'Veröffentlichen Sie einen paginierten Bericht auf der Quelldatenbank'),
        o('D', 'Use Q&A over the source database', 'Verwenden Sie Q&A über der Quelldatenbank')
      ],
      ['B'],
      t('Mirroring is designed to replicate supported source systems such as Azure SQL into Fabric with low latency. Unlike a shortcut, it creates local replicated data in OneLake for downstream analytics.', 'Mirroring ist dafür gedacht, unterstützte Quellsysteme wie Azure SQL mit geringer Latenz nach Fabric zu replizieren. Im Gegensatz zu einem Shortcut erzeugt es lokal replizierte Daten in OneLake für nachgelagerte Analysen.'),
      t('The requirement explicitly asks for replicated local data, not only virtualized access.', 'Die Anforderung verlangt ausdrücklich lokal replizierte Daten und nicht nur virtualisierten Zugriff.'),
      ref.mirroring),

    q('dp700-118', '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 operation', 'Es unterstützt Insert-, Update- und Delete-Logik in einem transaktionalen Vorgang'),
        o('B', 'It converts Delta tables into CSV automatically', 'Es konvertiert Delta-Tabellen automatisch in CSV'),
        o('C', 'It removes the need for keys', 'Es macht Schlüssel überflüssig'),
        o('D', 'It can run only from the SQL analytics endpoint', 'Es kann nur über den SQL-Analyseendpunkt ausgeführt werden')
      ],
      ['A'],
      t('MERGE is useful for upsert and change-processing patterns because it combines matching and nonmatching logic in a single statement. Delta tables support MERGE as part of reliable curated data processing.', 'MERGE ist für Upsert- und Änderungsverarbeitungsmuster nützlich, weil es Logik für passende und nicht passende Zeilen in einer einzigen Anweisung kombiniert. Delta-Tabellen unterstützen MERGE als Teil einer zuverlässigen Verarbeitung kuratierter Daten.'),
      t('Think of one statement for insert and update behavior.', 'Denken Sie an eine einzige Anweisung für Insert- und Update-Verhalten.'),
      ref.delta),

    q('dp700-119', 'single', prepare, 'medium',
      t('You need a transformation with custom Python libraries, complex branching logic, and distributed processing over hundreds of gigabytes.', 'Sie benötigen eine Transformation 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 built for large-scale code-first transformations and can use custom libraries. This makes them a strong choice for complex engineering tasks that exceed simple low-code shaping.', 'Spark-Notebooks sind für groß angelegte codebasierte Transformationen ausgelegt und können benutzerdefinierte Bibliotheken verwenden. Dadurch eignen sie sich gut für komplexe Engineering-Aufgaben, die einfache Low-Code-Formung übersteigen.'),
      t('Look for the option built for distributed custom code.', 'Suchen Sie nach der Option, die für verteilten benutzerdefinierten Code gedacht ist.'),
      ref.notebook),

    q('dp700-120', 'multiple', prepare, 'hard',
      t('A large Delta table receives frequent upserts and now contains many small files. Query performance has started to decline.', 'Eine große Delta-Tabelle erhält häufig Upserts und enthält nun viele kleine Dateien. Die Abfrageleistung beginnt zu sinken.'),
      t('Which two actions are most appropriate?', 'Welche zwei Maßnahmen sind am sinnvollsten?'),
      [
        o('A', 'Run table optimization or compaction to reduce small-file fragmentation', 'Führen Sie Tabellenoptimierung oder Kompaktierung aus, um die Fragmentierung durch kleine Dateien zu reduzieren'),
        o('B', 'Apply V-Order to improve read efficiency for analytical scans', 'Wenden Sie V-Order an, um die Leseeffizienz für analytische Scans zu verbessern'),
        o('C', 'Convert the table to JSON files for flexibility', 'Konvertieren Sie die Tabelle für mehr Flexibilität in JSON-Dateien'),
        o('D', 'Disable Delta transaction logs', 'Deaktivieren Sie Delta-Transaktionsprotokolle')
      ],
      ['A', 'B'],
      t('Frequent updates can create many small files, so compaction helps restore efficient file sizes. V-Order can further improve scan performance while keeping the Delta format intact.', 'Häufige Aktualisierungen können viele kleine Dateien erzeugen, daher hilft Kompaktierung dabei, effiziente Dateigrößen wiederherzustellen. V-Order kann die Scan-Leistung zusätzlich verbessern, während das Delta-Format erhalten bleibt.'),
      t('Address both file layout and read optimization.', 'Behandeln Sie sowohl das Dateilayout als auch die Leseoptimierung.'),
      ref.vorder),

    q('dp700-121', 'single', prepare, 'medium', null,
      t('What is the main purpose of VACUUM on 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 the table version history', 'Entfernen veralteter Dateien, die von der Versionshistorie der Tabelle nicht mehr benötigt werden'),
        o('B', 'Create a semantic model automatically', 'Automatisches Erstellen eines semantischen Modells'),
        o('C', 'Add new columns from source data', 'Neue Spalten aus Quelldaten hinzufügen'),
        o('D', 'Turn the table into a warehouse table', 'Die Tabelle in eine Warehouse-Tabelle umwandeln')
      ],
      ['A'],
      t('VACUUM cleans up old files that remain after updates and deletes in Delta storage once they are outside the configured retention window. It helps reclaim storage and reduce file clutter.', 'VACUUM bereinigt alte Dateien, die nach Updates und Deletes im Delta-Speicher verbleiben, sobald sie außerhalb des konfigurierten Aufbewahrungsfensters liegen. Das hilft, Speicher zurückzugewinnen und Dateiwildwuchs zu reduzieren.'),
      t('Think cleanup of stale physical files.', 'Denken Sie an die Bereinigung veralteter physischer Dateien.'),
      ref.delta),

    q('dp700-122', '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 notebooks for ETL orchestration', 'Er ersetzt Spark-Notebooks für ETL-Orchestrierung'),
        o('D', 'It stores data outside OneLake by default', 'Er speichert Daten standardmäßig außerhalb von OneLake')
      ],
      ['A'],
      t('The SQL analytics endpoint provides SQL access to lakehouse tables without moving the data, but it is read-only. Write-heavy relational authoring scenarios fit a warehouse better.', 'Der SQL-Analyseendpunkt bietet SQL-Zugriff auf Lakehouse-Tabellen, ohne die Daten zu verschieben, ist aber schreibgeschützt. Schreibintensive relationale Entwicklungsszenarien passen besser zu einem Warehouse.'),
      t('Remember the endpoint is for querying, not general write-back.', 'Denken Sie daran, dass der Endpunkt für Abfragen und nicht für allgemeine Schreibvorgänge gedacht ist.'),
      ref.queryWarehouse),

    q('dp700-123', 'single', prepare, 'medium',
      t('A warehouse team must create a new summary table from an existing fact table by using T-SQL in a single operation during deployment.', 'Ein Warehouse-Team muss während der Bereitstellung mit T-SQL in einem einzigen Vorgang eine neue 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 a bookmark', 'Verwenden Sie ein Lesezeichen'),
        o('C', 'Use VACUUM', 'Verwenden Sie VACUUM'),
        o('D', 'Use a OneLake shortcut', 'Verwenden Sie einen OneLake-Shortcut')
      ],
      ['A'],
      t('CTAS is a common warehouse pattern for creating a new table from a query result in one step. It is useful for deployment-time staging, snapshots, or derived summary tables.', 'CTAS ist ein gängiges Warehouse-Muster, um in einem Schritt aus einem Abfrageergebnis eine neue Tabelle zu erzeugen. Es ist nützlich für Bereitstellungs-Staging, Snapshots oder abgeleitete Summierungstabellen.'),
      t('Think create-plus-load in one statement.', 'Denken Sie an Erstellen plus Laden in einer Anweisung.'),
      ref.warehouse),

    q('dp700-124', 'single', prepare, 'medium', null,
      t('Why would you use a stored procedure in a Fabric warehouse?', 'Warum würden Sie in einem Fabric Warehouse eine gespeicherte Prozedur verwenden?'),
      [
        o('A', 'To encapsulate repeatable SQL logic such as load steps and validations', 'Um wiederholbare SQL-Logik wie Ladeschritte und Validierungen zu kapseln'),
        o('B', 'To create notebook visualizations', 'Um Notebook-Visualisierungen zu erstellen'),
        o('C', 'To assign workspace roles', 'Um Arbeitsbereichsrollen zuzuweisen'),
        o('D', 'To replace semantic model measures', 'Um Measures in semantischen Modellen zu ersetzen')
      ],
      ['A'],
      t('Stored procedures are useful for packaging repeatable warehouse logic behind a callable interface. This improves reuse and keeps orchestration cleaner when pipelines invoke SQL workloads.', 'Gespeicherte Prozeduren sind nützlich, um wiederholbare Warehouse-Logik hinter einer aufrufbaren Schnittstelle zu verpacken. Das verbessert die Wiederverwendung und hält die Orchestrierung sauberer, wenn Pipelines SQL-Workloads aufrufen.'),
      t('Choose the database object for reusable SQL processing logic.', 'Wählen Sie das Datenbankobjekt für wiederverwendbare SQL-Verarbeitungslogik.'),
      ref.warehouse),

    q('dp700-125', 'single', prepare, 'hard', null,
      t('How can you query tables from another Fabric warehouse in the same workspace from a warehouse SQL editor?', 'Wie können Sie im SQL-Editor eines Warehouses Tabellen aus einem anderen Fabric Warehouse im selben Arbeitsbereich abfragen?'),
      [
        o('A', 'Use three-part names that reference the other database, schema, and object', 'Verwenden Sie dreiteilige Namen, die auf die andere Datenbank, das Schema und das Objekt verweisen'),
        o('B', 'Use DAX relationships between warehouses', 'Verwenden Sie DAX-Beziehungen zwischen Warehouses'),
        o('C', 'Export both warehouses to Excel first', 'Exportieren Sie zunächst beide Warehouses nach Excel'),
        o('D', 'Create a bookmark for the second warehouse', 'Erstellen Sie ein Lesezeichen für das zweite Warehouse')
      ],
      ['A'],
      t('Fabric supports cross-warehouse queries within the same workspace by referencing objects with T-SQL naming conventions. This allows one query to join data across multiple Fabric SQL items.', 'Fabric unterstützt Cross-Warehouse-Abfragen innerhalb desselben Arbeitsbereichs, indem Objekte mit T-SQL-Namenskonventionen referenziert werden. Dadurch kann eine Abfrage Daten über mehrere Fabric-SQL-Elemente hinweg verknüpfen.'),
      t('Think standard SQL naming, not report-layer features.', 'Denken Sie an Standard-SQL-Namensgebung und nicht an Berichtsfunktionen.'),
      ref.crossWarehouse),

    q('dp700-126', 'single', prepare, 'hard',
      t('You need a safe copy of a production warehouse table for testing today, and you want the copy created immediately with minimal additional storage.', 'Sie benötigen heute eine sichere Kopie einer Produktions-Warehouse-Tabelle für Tests, und die Kopie soll sofort mit minimalem zusätzlichem Speicher erstellt werden.'),
      t('Which Fabric feature best fits?', 'Welche Fabric-Funktion passt am besten?'),
      [
        o('A', 'Table clone', 'Tabellenklon'),
        o('B', 'Bookmark', 'Lesezeichen'),
        o('C', 'Shortcut', 'Shortcut'),
        o('D', 'Semantic model refresh', 'Aktualisierung des semantischen Modells')
      ],
      ['A'],
      t('A table clone creates a near-instant, zero-copy clone of a warehouse table. It is designed for test, recovery, and point-in-time scenarios without physically duplicating all data files.', 'Ein Tabellenklon erstellt nahezu sofort einen Zero-Copy-Klon einer Warehouse-Tabelle. Er ist für Test-, Recovery- und Point-in-Time-Szenarien gedacht, ohne alle Datendateien physisch zu duplizieren.'),
      t('Choose the feature made for instant low-storage copies.', 'Wählen Sie die Funktion, die für sofortige Kopien mit geringem Speicherbedarf gedacht ist.'),
      ref.clone),

    q('dp700-127', 'multiple', prepare, 'medium', null,
      t('Which two statements correctly describe Fabric Data Factory capabilities?', 'Welche zwei Aussagen beschreiben die Fähigkeiten von Fabric Data Factory korrekt?'),
      [
        o('A', 'Copy activity is optimized for moving data from source to destination', 'Die Copy Activity ist für das Verschieben von Daten von Quelle zu Ziel optimiert'),
        o('B', 'Dataflows Gen2 use Power Query for low-code transformation', 'Dataflows Gen2 verwenden Power Query für Low-Code-Transformationen'),
        o('C', 'Pipelines can be used only for real-time event ingestion', 'Pipelines können nur für die Echtzeitaufnahme von Ereignissen verwendet werden'),
        o('D', 'Dataflows Gen2 can create workspace roles automatically', 'Dataflows Gen2 können Arbeitsbereichsrollen automatisch erstellen')
      ],
      ['A', 'B'],
      t('Copy activity is designed for data movement, while Dataflows Gen2 provide Power Query based transformation. Pipelines orchestrate many batch tasks and are not limited to real-time ingestion.', 'Die Copy Activity ist für Datenbewegung vorgesehen, während Dataflows Gen2 Power-Query-basierte Transformationen bereitstellen. Pipelines orchestrieren viele Batch-Aufgaben und sind nicht auf Echtzeitaufnahme beschränkt.'),
      t('Pair the movement feature with the low-code transformation feature.', 'Kombinieren Sie die Bewegungsfunktion mit der Low-Code-Transformationsfunktion.'),
      ref.pipelines),

    q('dp700-128', 'single', prepare, 'medium', null,
      t('Which Fabric experience lets analysts shape data with Power Query and then load it into a destination such as a lakehouse or warehouse?', 'Welche Fabric-Erfahrung ermöglicht es Analysten, Daten mit Power Query aufzubereiten und anschließend in ein Ziel wie 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 transformation experience powered by Power Query and can write to Fabric destinations. They are often used when business-friendly shaping is preferred over code-first notebooks.', 'Dataflows Gen2 bieten eine Low-Code-Transformationserfahrung auf Basis von Power Query und können in Fabric-Ziele schreiben. Sie werden häufig verwendet, wenn eine geschäftsfreundliche Datenaufbereitung gegenüber codebasierten Notebooks bevorzugt wird.'),
      t('Think Power Query plus loading to Fabric destinations.', 'Denken Sie an Power Query plus Laden in Fabric-Ziele.'),
      ref.dataflows),

    q('dp700-129', 'multiple', prepare, 'medium',
      t('A pipeline must run every night, and the same logic should support dev and prod by passing different source paths as parameters.', 'Eine Pipeline muss jede Nacht laufen, und dieselbe Logik soll Entwicklung und Produktion unterstützen, indem unterschiedliche Quellpfade als Parameter übergeben werden.'),
      t('Which two pipeline capabilities should you use?', 'Welche zwei Pipeline-Funktionen sollten Sie verwenden?'),
      [
        o('A', 'A schedule trigger', 'Einen Zeitplan-Trigger'),
        o('B', 'Pipeline parameters', 'Pipeline-Parameter'),
        o('C', 'Report bookmarks', 'Berichtslesezeichen'),
        o('D', 'Object-level security', 'Object-Level-Security')
      ],
      ['A', 'B'],
      t('Schedule triggers automate the nightly run, and parameters let the same pipeline logic vary by environment or source location. This is a standard pattern for reusable orchestration.', 'Zeitplan-Trigger automatisieren den nächtlichen Lauf, und Parameter erlauben es, dieselbe Pipeline-Logik je nach Umgebung oder Quellpfad zu variieren. Dies ist ein Standardmuster für wiederverwendbare Orchestrierung.'),
      t('One capability controls when it runs, the other controls what values it uses.', 'Eine Funktion steuert, wann sie läuft, die andere, welche Werte sie verwendet.'),
      ref.pipelines),

    q('dp700-130', 'multiple', prepare, 'hard',
      t('A metadata table lists 200 source files that must each be copied and then validated. You want one orchestration pattern instead of 200 manually duplicated activities.', 'Eine Metadatentabelle listet 200 Quelldateien auf, die jeweils kopiert und anschließend validiert werden müssen. Sie möchten ein Orchestrierungsmuster statt 200 manuell 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 the listed items', 'ForEach-Aktivität zum Durchlaufen der aufgelisteten Elemente'),
        o('C', 'Bookmark navigator to branch pipeline logic', 'Lesezeichen-Navigator zum Verzweigen der Pipeline-Logik'),
        o('D', 'Q&A visual to parameterize activity names', 'Q&A-Visual zur Parametrisierung von Aktivitätsnamen')
      ],
      ['A', 'B'],
      t('Metadata-driven orchestration commonly uses a lookup to read control data and a ForEach loop to iterate over each item. This avoids hardcoding many repeated activities.', 'Metadatengesteuerte Orchestrierung verwendet häufig ein Lookup zum Lesen von Steuerdaten und eine ForEach-Schleife, um über jedes Element zu iterieren. Dadurch werden viele wiederholte Aktivitäten nicht fest verdrahtet.'),
      t('Think metadata first, then iteration.', 'Denken Sie zuerst an Metadaten und dann an Iteration.'),
      ref.pipelines),

    q('dp700-131', 'single', prepare, 'medium',
      t('A team wants analysts to browse shared parquet files in an S3 bucket from Fabric immediately, but they do not want to build an ingestion pipeline yet.', 'Ein Team möchte, dass Analysten gemeinsam genutzte Parquet-Dateien in einem S3-Bucket sofort aus Fabric heraus durchsuchen können, möchte aber noch keine Ingestionspipeline bauen.'),
      t('What should you implement?', 'Was sollten Sie implementieren?'),
      [
        o('A', 'A OneLake shortcut to the S3 location', 'Einen OneLake-Shortcut zum S3-Speicherort'),
        o('B', 'A warehouse clone', 'Einen Warehouse-Klon'),
        o('C', 'An incremental refresh policy', 'Eine Richtlinie für inkrementelle Aktualisierung'),
        o('D', 'A calculation group', 'Eine Berechnungsgruppe')
      ],
      ['A'],
      t('A shortcut exposes the external data in Fabric without waiting for a full ingestion process. It is useful for rapid access when duplication is not desired.', 'Ein Shortcut macht die externen Daten in Fabric zugänglich, ohne auf einen vollständigen Ingestionsprozess zu warten. Er ist nützlich für schnellen Zugriff, wenn keine Duplizierung gewünscht ist.'),
      t('Choose the no-copy access pattern.', 'Wählen Sie das Zugriffsmuster ohne Kopie.'),
      ref.shortcuts),

    q('dp700-132', 'single', prepare, 'hard',
      t('Your analytics team wants near real-time copies of Azure SQL tables in OneLake with minimal custom ETL code.', 'Ihr Analyseteam möchte nahezu in Echtzeit Kopien von Azure-SQL-Tabellen in OneLake mit minimalem benutzerdefiniertem ETL-Code.'),
      t('Which statement about mirroring is most relevant?', 'Welche Aussage über Mirroring ist am relevantesten?'),
      [
        o('A', 'Mirroring replicates supported source systems into Fabric and keeps them synchronized', 'Mirroring repliziert unterstützte Quellsysteme nach Fabric und hält sie synchronisiert'),
        o('B', 'Mirroring is only for CSV folders', 'Mirroring ist nur für CSV-Ordner gedacht'),
        o('C', 'Mirroring can be used only from Power BI Desktop', 'Mirroring kann nur aus Power BI Desktop verwendet werden'),
        o('D', 'Mirroring never creates Delta-formatted data in OneLake', 'Mirroring erzeugt niemals Delta-formatierte Daten in OneLake')
      ],
      ['A'],
      t('Mirroring is built for low-latency replication of supported sources such as Azure SQL into Fabric. It reduces the need for custom extraction pipelines when the goal is synchronized analytical copies.', 'Mirroring ist für die Replikation unterstützter Quellen wie Azure SQL nach Fabric mit geringer Latenz ausgelegt. Es reduziert den Bedarf an benutzerdefinierten Extraktionspipelines, wenn synchronisierte analytische Kopien das Ziel sind.'),
      t('The requirement emphasizes replicated synchronized copies.', 'Die Anforderung betont replizierte, synchronisierte Kopien.'),
      ref.mirroring),

    q('dp700-133', 'multiple', prepare, 'hard',
      t('A source system is an operational database that analysts query heavily throughout the day. The source team worries that direct read traffic could affect their application.', 'Ein Quellsystem ist eine operative Datenbank, die von Analysten tagsüber stark abgefragt wird. Das Quellteam befürchtet, dass direkte Lesezugriffe die Anwendung beeinträchtigen könnten.'),
      t('Which two reasons support using mirroring instead of a shortcut?', 'Welche zwei Gründe sprechen für Mirroring statt eines Shortcuts?'),
      [
        o('A', 'Queries can run against replicated data in Fabric instead of the operational source', 'Abfragen können gegen replizierte Daten in Fabric statt gegen die operative Quelle laufen'),
        o('B', 'Mirroring avoids all storage usage in OneLake', 'Mirroring vermeidet jeglichen Speicherverbrauch in OneLake'),
        o('C', 'Mirroring can provide low-latency local copies for analytics', 'Mirroring kann lokale Kopien mit geringer Latenz für Analysen bereitstellen'),
        o('D', 'Mirroring is the only way to create a workspace', 'Mirroring ist die einzige Möglichkeit, einen Arbeitsbereich zu erstellen')
      ],
      ['A', 'C'],
      t('Mirroring creates replicated analytical copies in Fabric so consumers can query local data instead of stressing the operational system. That improves isolation and can reduce query impact on production sources.', 'Mirroring erstellt replizierte analytische Kopien in Fabric, sodass Verbraucher lokale Daten abfragen können, statt das operative System zu belasten. Das verbessert die Isolation und kann die Abfragebelastung der Produktionsquellen verringern.'),
      t('Look for answers about isolating analytics from the operational workload.', 'Suchen Sie nach Antworten zur Trennung von Analytik und operativem Workload.'),
      ref.mirroring),

    q('dp700-134', 'single', prepare, 'easy', null,
      t('In a medallion architecture implemented in Fabric, what is the typical role of the silver layer?', 'Welche typische Rolle hat in einer mit Fabric umgesetzten Medaillon-Architektur die Silver-Schicht?'),
      [
        o('A', 'Raw landed data with minimal validation', 'Roh angekommene Daten mit minimaler Validierung'),
        o('B', 'Cleansed and conformed data prepared from bronze', 'Bereinigte und angeglichene Daten, die aus Bronze vorbereitet wurden'),
        o('C', 'Final executive Power BI report pages', 'Finale Power-BI-Berichtsseiten für Führungskräfte'),
        o('D', 'Tenant settings and capacity assignments', 'Mandanteneinstellungen und Kapazitätszuweisungen')
      ],
      ['B'],
      t('Silver commonly contains validated, standardized, and enriched data that is ready for broader reuse. It sits between raw bronze ingestion and curated gold serving layers.', 'Silver enthält üblicherweise validierte, standardisierte und angereicherte Daten, die für breitere Wiederverwendung bereit sind. Sie liegt zwischen der rohen Bronze-Aufnahme und den kuratierten Gold-Bereitstellungsschichten.'),
      t('Bronze is raw, silver is refined, gold is business-ready.', 'Bronze ist roh, Silver veredelt, Gold geschäftsbereit.'),
      ref.lakehouse),

    q('dp700-135', 'single', prepare, 'medium',
      t('You must join several very large parquet datasets, apply custom Python logic, and output a managed Delta table for downstream use.', 'Sie müssen mehrere sehr große Parquet-Datensätze verknüpfen, benutzerdefinierte Python-Logik anwenden und eine verwaltete Delta-Tabelle für die nachgelagerte Nutzung ausgeben.'),
      t('Which authoring experience is the best fit?', 'Welche Authoring-Erfahrung ist am besten geeignet?'),
      [
        o('A', 'Spark notebook', 'Spark-Notebook'),
        o('B', 'Bookmark pane', 'Lesezeichenbereich'),
        o('C', 'KQL dashboard', 'KQL-Dashboard'),
        o('D', 'Workspace access page', 'Seite für Arbeitsbereichszugriff')
      ],
      ['A'],
      t('A Spark notebook supports distributed transformation code, Python libraries, and writing Delta outputs. This is the best match for large-scale custom engineering.', 'Ein Spark-Notebook unterstützt verteilten Transformationscode, Python-Bibliotheken und das Schreiben von Delta-Ausgaben. Das ist die beste Wahl für groß angelegtes benutzerdefiniertes Engineering.'),
      t('Choose the code-first distributed processing tool.', 'Wählen Sie das codebasierte Werkzeug für verteilte Verarbeitung.'),
      ref.notebook),

    q('dp700-136', 'multiple', prepare, 'hard',
      t('A curated Delta table is updated continuously. You want to keep query performance healthy and remove stale files that are no longer needed after retention expires.', 'Eine kuratierte Delta-Tabelle wird kontinuierlich aktualisiert. Sie möchten die Abfrageleistung gesund halten und veraltete Dateien entfernen, die nach Ablauf der Aufbewahrungsfrist nicht mehr benötigt werden.'),
      t('Which two maintenance actions should you plan?', 'Welche zwei Wartungsmaßnahmen sollten Sie einplanen?'),
      [
        o('A', 'Optimize or compact files', 'Dateien optimieren oder komprimieren'),
        o('B', 'Run VACUUM with an appropriate retention policy', 'Führen Sie VACUUM mit einer geeigneten Aufbewahrungsrichtlinie aus'),
        o('C', 'Disable transaction logs', 'Deaktivieren Sie Transaktionsprotokolle'),
        o('D', 'Replace the table with a bookmark', 'Ersetzen Sie die Tabelle durch ein Lesezeichen')
      ],
      ['A', 'B'],
      t('Compaction addresses small-file fragmentation, while VACUUM removes obsolete files outside the retention window. Together these actions support healthy Delta table maintenance.', 'Kompaktierung behandelt die Fragmentierung durch kleine Dateien, während VACUUM veraltete Dateien außerhalb des Aufbewahrungsfensters entfernt. Zusammen unterstützen diese Maßnahmen eine gesunde Wartung von Delta-Tabellen.'),
      t('One action helps performance, the other cleans old storage artifacts.', 'Eine Maßnahme hilft der Leistung, die andere bereinigt alte Speicherartefakte.'),
      ref.vorder),

    q('dp700-137', 'single', prepare, 'medium', null,
      t('In a dimensional warehouse model, where should descriptive attributes such as Product Name and Brand usually be stored?', 'Wo sollten in einem dimensionalen Warehouse-Modell beschreibende Attribute wie Produktname und Marke normalerweise gespeichert werden?'),
      [
        o('A', 'In a dimension table', 'In einer Dimensionstabelle'),
        o('B', 'In every report visual separately', 'Separat in jedem Berichtsvisual'),
        o('C', 'Only in bookmarks', 'Nur in Lesezeichen'),
        o('D', 'Inside tenant settings', 'In Mandanteneinstellungen')
      ],
      ['A'],
      t('Descriptive business attributes belong in dimensions, while fact tables typically store keys and measurements. This separation is central to star schema design.', 'Beschreibende Geschäftsattribute gehören in Dimensionen, während Faktentabellen typischerweise Schlüssel und Kennzahlen speichern. Diese Trennung ist zentral für das Sternschema-Design.'),
      t('Dimensions describe entities, facts record events.', 'Dimensionen beschreiben Entitäten, Fakten erfassen Ereignisse.'),
      ref.star),

    q('dp700-138', 'single', prepare, 'medium', null,
      t('What is a common tradeoff of a snowflake schema compared to a star schema for BI consumption?', 'Welcher typische Zielkonflikt besteht bei einem Snowflake-Schema im Vergleich zu einem Sternschema für BI-Konsum?'),
      [
        o('A', 'It can reduce some redundancy but often adds more joins and complexity', 'Es kann gewisse Redundanz reduzieren, fügt aber oft mehr Joins und Komplexität hinzu'),
        o('B', 'It eliminates the need for relationships entirely', 'Es beseitigt die Notwendigkeit von Beziehungen vollständig'),
        o('C', 'It is required for all Direct Lake models', 'Es ist für alle Direct-Lake-Modelle erforderlich'),
        o('D', 'It stores only aggregated values', 'Es speichert nur aggregierte Werte')
      ],
      ['A'],
      t('A snowflake schema can normalize dimensions further, but that often increases model complexity and join depth. Star schemas are usually preferred for clarity and BI performance.', 'Ein Snowflake-Schema kann Dimensionen weiter normalisieren, erhöht aber oft Modellkomplexität und Join-Tiefe. Sternschemata werden meist wegen Klarheit und BI-Leistung bevorzugt.'),
      t('Less redundancy can mean more join complexity.', 'Weniger Redundanz kann mehr Join-Komplexität bedeuten.'),
      ref.star),

    q('dp700-139', 'single', prepare, 'medium', null,
      t('When designing relationships between tables, what is an important rule for key columns?', 'Was ist eine wichtige Regel für Schlüsselspalten beim Entwerfen von Beziehungen zwischen Tabellen?'),
      [
        o('A', 'They should usually use compatible data types and matching business meaning', 'Sie sollten in der Regel kompatible Datentypen und dieselbe fachliche Bedeutung haben'),
        o('B', 'They should always be text in every model', 'Sie sollten in jedem Modell immer Text sein'),
        o('C', 'They should be hidden from the data source', 'Sie sollten vor der Datenquelle verborgen sein'),
        o('D', 'They should be replaced by bookmarks', 'Sie sollten durch Lesezeichen ersetzt werden')
      ],
      ['A'],
      t('Relationship keys must line up in both meaning and data type so filters and joins behave correctly. Mismatched types or semantics are common causes of model issues.', 'Beziehungsschlüssel müssen sowohl fachlich als auch hinsichtlich des Datentyps übereinstimmen, damit Filter und Joins korrekt funktionieren. Nicht übereinstimmende Typen oder Semantik sind häufige Ursachen für Modellprobleme.'),
      t('Think compatible key columns for reliable joins.', 'Denken Sie an kompatible Schlüsselspalten für zuverlässige Joins.'),
      ref.relationships),

    q('dp700-140', 'single', prepare, 'easy', null,
      t('What does a fact table usually contain in a star schema?', 'Was enthält eine Faktentabelle in einem Sternschema normalerweise?'),
      [
        o('A', 'Measurements and foreign keys to dimensions', 'Kennzahlen und Fremdschlüssel zu Dimensionen'),
        o('B', 'Only report bookmarks', 'Nur Berichtslesezeichen'),
        o('C', 'Workspace role assignments', 'Zuweisungen von Arbeitsbereichsrollen'),
        o('D', 'Only natural language synonyms', 'Nur Synonyme für natürliche Sprache')
      ],
      ['A'],
      t('Fact tables store business events or transactions at a chosen grain, along with numeric measures and foreign keys that connect to dimensions.', 'Faktentabellen speichern Geschäftsvorfälle oder Transaktionen in einer gewählten Granularität zusammen mit numerischen Kennzahlen und Fremdschlüsseln, die zu Dimensionen verbinden.'),
      t('Facts record events and measurements.', 'Fakten erfassen Ereignisse und Kennzahlen.'),
      ref.star),

    q('dp700-141', 'multiple', prepare, 'hard',
      t('An IoT solution sends millions of device events per day. Operations wants immediate investigation in KQL, while engineering wants long-term historical storage for broader analytics.', 'Eine IoT-Lösung sendet Millionen von Geräteereignissen pro Tag. Der Betrieb möchte sofortige Untersuchung in KQL, während das Engineering langfristige historische Speicherung für breitere Analysen wünscht.'),
      t('Which two destinations are a strong fit when using Eventstream?', 'Welche zwei Ziele passen bei Verwendung von Eventstream besonders gut?'),
      [
        o('A', 'A KQL database for real-time analysis', 'Eine KQL-Datenbank für Echtzeitanalyse'),
        o('B', 'A lakehouse for historical analytical storage', 'Ein Lakehouse für historische analytische Speicherung'),
        o('C', 'A bookmark collection', 'Eine Lesezeichensammlung'),
        o('D', 'A workspace role', 'Eine Arbeitsbereichsrolle')
      ],
      ['A', 'B'],
      t('Eventstream is designed to route real-time events into analytical destinations such as KQL databases and lakehouses. This supports both immediate operational analysis and broader historical use.', 'Eventstream ist dafür gedacht, Echtzeitereignisse in analytische Ziele wie KQL-Datenbanken und Lakehouses zu leiten. Das unterstützt sowohl unmittelbare operative Analysen als auch breitere historische Nutzung.'),
      t('Pair a real-time store with a long-term analytical store.', 'Kombinieren Sie einen Echtzeitspeicher mit einem langfristigen analytischen Speicher.'),
      ref.eventstream),

    q('dp700-142', 'single', prepare, 'medium', null,
      t('What is a common benefit of adding a transformation step inside an Eventstream before the destination?', 'Was ist ein häufiger Vorteil eines Transformationsschritts in einem Eventstream vor dem Ziel?'),
      [
        o('A', 'You can filter, reshape, or enrich events before they land downstream', 'Sie können Ereignisse filtern, umformen oder anreichern, bevor sie im Ziel landen'),
        o('B', 'You can create workspace roles automatically', 'Sie können Arbeitsbereichsrollen automatisch erstellen'),
        o('C', 'You can convert KQL into DAX', 'Sie können KQL in DAX umwandeln'),
        o('D', 'You can bypass all security controls', 'Sie können alle Sicherheitskontrollen umgehen')
      ],
      ['A'],
      t('Eventstream transformations help reduce downstream work by shaping events before they are stored or queried. This can improve quality and reduce noise in the target system.', 'Eventstream-Transformationen helfen dabei, nachgelagerte Arbeit zu reduzieren, indem Ereignisse geformt werden, bevor sie gespeichert oder abgefragt werden. Das kann die Qualität verbessern und Rauschen im Zielsystem verringern.'),
      t('Think about lightweight processing before delivery.', 'Denken Sie an leichte Verarbeitung vor der Zustellung.'),
      ref.eventstream),

    q('dp700-143', 'single', prepare, 'medium',
      t('A multi-step Fabric pipeline failed on the final warehouse load after the earlier ingestion steps finished successfully. You want to continue from the failed point rather than rerun everything.', 'Eine mehrstufige Fabric-Pipeline ist beim letzten Warehouse-Ladevorgang fehlgeschlagen, nachdem die vorherigen Ingestionsschritte erfolgreich waren. Sie möchten vom Fehlerpunkt aus fortsetzen, statt alles erneut auszuführen.'),
      t('What should you use?', 'Was sollten Sie verwenden?'),
      [
        o('A', 'Rerun only the failed activity or resume from failure', 'Führen Sie nur die fehlgeschlagene Aktivität erneut aus oder setzen Sie ab dem Fehler fort'),
        o('B', 'Delete the whole pipeline and recreate it', 'Löschen Sie die gesamte Pipeline und erstellen Sie sie neu'),
        o('C', 'Use a report bookmark', 'Verwenden Sie ein Berichtslesezeichen'),
        o('D', 'Disable dependencies permanently', 'Deaktivieren Sie Abhängigkeiten dauerhaft')
      ],
      ['A'],
      t('Pipelines are designed to support failure handling and targeted reruns. When only one late stage fails, rerunning from the failed point is more efficient than repeating already successful steps.', 'Pipelines sind dafür ausgelegt, Fehlerbehandlung und gezielte Wiederholungen zu unterstützen. Wenn nur eine späte Stufe fehlschlägt, ist das Fortsetzen ab dem Fehlerpunkt effizienter, als bereits erfolgreiche Schritte zu wiederholen.'),
      t('Do not repeat successful work unnecessarily.', 'Wiederholen Sie erfolgreiche Arbeit nicht unnötig.'),
      ref.pipelines),

    q('dp700-144', 'single', prepare, 'easy', null,
      t('Which Fabric feature is primarily used to copy files or table data from a source system into a lakehouse bronze layer?', 'Welche Fabric-Funktion wird primär verwendet, um Dateien oder Tabellendaten aus einem Quellsystem in eine Bronze-Schicht eines Lakehouse zu kopieren?'),
      [
        o('A', 'Copy activity in a pipeline', 'Copy Activity in einer Pipeline'),
        o('B', 'Bookmark navigator', 'Lesezeichen-Navigator'),
        o('C', 'Drillthrough target', 'Drillthrough-Ziel'),
        o('D', 'Object-level security role', 'Object-Level-Security-Rolle')
      ],
      ['A'],
      t('Copy activity is optimized for data movement between sources and Fabric destinations. It is a common choice for bronze ingestion workflows.', 'Die Copy Activity ist für Datenbewegung zwischen Quellen und Fabric-Zielen optimiert. Sie ist eine häufige Wahl für Bronze-Ingestionsworkflows.'),
      t('Choose the movement-oriented activity.', 'Wählen Sie die bewegungsorientierte Aktivität.'),
      ref.pipelines),

    q('dp700-145', 'single', prepare, 'medium',
      t('A finance team wants to combine SharePoint files, Excel sheets, and a SQL table by using a low-code interface before loading curated output to Fabric.', 'Ein Finanzteam möchte SharePoint-Dateien, Excel-Tabellen und eine SQL-Tabelle über eine Low-Code-Oberfläche kombinieren, bevor kuratierte Ergebnisse nach Fabric geladen werden.'),
      t('Which Fabric capability best fits?', 'Welche Fabric-Funktion passt am besten?'),
      [
        o('A', 'Dataflow Gen2', 'Dataflow Gen2'),
        o('B', 'KQL dashboard', 'KQL-Dashboard'),
        o('C', 'Capacity metrics app', 'Kapazitätsmetriken-App'),
        o('D', 'Deployment pipeline', 'Deployment-Pipeline')
      ],
      ['A'],
      t('Dataflows Gen2 are designed for low-code data ingestion and shaping across many business-friendly sources. They are a strong match when the team prefers Power Query over custom code.', 'Dataflows Gen2 sind für Low-Code-Datenaufnahme und -aufbereitung über viele geschäftsfreundliche Quellen hinweg gedacht. Sie passen gut, wenn das Team Power Query gegenüber benutzerdefiniertem Code bevorzugt.'),
      t('Look for the Power Query based transformation option.', 'Suchen Sie nach der Power-Query-basierten Transformationsoption.'),
      ref.dataflows),

    q('dp700-146', 'single', prepare, 'medium', null,
      t('Why would a consumer domain create a shortcut to a certified lakehouse in another workspace instead of copying the data?', 'Warum würde eine Verbraucherdomäne einen Shortcut zu einem zertifizierten Lakehouse in einem anderen Arbeitsbereich erstellen, statt die Daten zu kopieren?'),
      [
        o('A', 'To reuse the same governed data product with minimal duplication', 'Um dasselbe kontrollierte Datenprodukt mit minimaler Duplizierung wiederzuverwenden'),
        o('B', 'To bypass source permissions completely', 'Um Quellberechtigungen vollständig zu umgehen'),
        o('C', 'To convert Delta tables into bookmarks', 'Um Delta-Tabellen in Lesezeichen umzuwandeln'),
        o('D', 'To disable lineage tracking', 'Um Lineage-Nachverfolgung zu deaktivieren')
      ],
      ['A'],
      t('Shortcuts are useful for reusing trusted data products across workspaces without creating unnecessary copies. This supports consistency and reduces storage sprawl.', 'Shortcuts sind nützlich, um vertrauenswürdige Datenprodukte über Arbeitsbereiche hinweg wiederzuverwenden, ohne unnötige Kopien zu erzeugen. Das unterstützt Konsistenz und reduziert Speicherwildwuchs.'),
      t('The best answer keeps one trusted source of data.', 'Die beste Antwort erhält eine vertrauenswürdige Datenquelle.'),
      ref.shortcuts),

    q('dp700-147', 'single', prepare, 'easy', null,
      t('What is the main purpose of the OneLake catalog or Data Hub experience?', 'Was ist der Hauptzweck des OneLake-Katalogs bzw. der Data-Hub-Erfahrung?'),
      [
        o('A', 'Discover, explore, and govern available Fabric data items', 'Verfügbare Fabric-Datenelemente entdecken, erkunden und steuern'),
        o('B', 'Author DAX measures in semantic models', 'DAX-Measures in semantischen Modellen erstellen'),
        o('C', 'Replace all workspace permissions', 'Alle Arbeitsbereichsberechtigungen ersetzen'),
        o('D', 'Run Spark jobs without a lakehouse', 'Spark-Jobs ohne Lakehouse ausführen')
      ],
      ['A'],
      t('The catalog helps users find and understand data assets across Fabric so they can reuse trusted items instead of recreating them. It also supports governance and discoverability.', 'Der Katalog hilft Benutzern, Datenbestände in Fabric zu finden und zu verstehen, damit sie vertrauenswürdige Elemente wiederverwenden statt neu zu erstellen. Er unterstützt außerdem Governance und Auffindbarkeit.'),
      t('Think centralized discovery and governance of data assets.', 'Denken Sie an zentrale Auffindbarkeit und Governance von Datenbeständen.'),
      ref.catalog),

    q('dp700-148', 'single', prepare, 'hard',
      t('A retailer stores operational data in Snowflake and wants near real-time analytics in Fabric without maintaining a complex custom CDC pipeline.', 'Ein Einzelhändler speichert operative Daten in Snowflake und möchte nahezu Echtzeit-Analysen in Fabric, ohne eine komplexe benutzerdefinierte CDC-Pipeline zu pflegen.'),
      t('What is the best first option to evaluate?', 'Welche erste Option sollten Sie prüfen?'),
      [
        o('A', 'Mirroring', 'Mirroring'),
        o('B', 'Report bookmarks', 'Berichtslesezeichen'),
        o('C', 'Power BI themes', 'Power-BI-Designs'),
        o('D', 'Object-level security', 'Object-Level-Security')
      ],
      ['A'],
      t('Mirroring supports selected source systems, including Snowflake, to replicate data into Fabric with low-latency synchronization. It is appropriate when the goal is analytical copies without building everything by hand.', 'Mirroring unterstützt ausgewählte Quellsysteme, darunter Snowflake, um Daten mit Synchronisierung geringer Latenz nach Fabric zu replizieren. Das ist geeignet, wenn analytische Kopien ohne vollständigen Eigenbau gewünscht sind.'),
      t('The scenario asks for low-code replication into Fabric.', 'Das Szenario verlangt nach Replikation mit wenig Eigenentwicklung nach Fabric.'),
      ref.mirroring),

    q('dp700-149', 'single', prepare, 'hard',
      t('An application stores semi-structured transactional data in Azure Cosmos DB. Analysts need low-latency access to that data in Fabric for downstream reporting and data engineering.', 'Eine Anwendung speichert semistrukturierte Transaktionsdaten in Azure Cosmos DB. Analysten benötigen in Fabric Zugriff mit geringer Latenz für nachgelagerte Berichte und Data Engineering.'),
      t('Which Fabric feature should you evaluate first?', 'Welche Fabric-Funktion sollten Sie zuerst prüfen?'),
      [
        o('A', 'Mirroring', 'Mirroring'),
        o('B', 'Bookmark navigation', 'Lesezeichennavigation'),
        o('C', 'Calculation groups', 'Berechnungsgruppen'),
        o('D', 'Deployment pipelines', 'Deployment-Pipelines')
      ],
      ['A'],
      t('Mirroring is designed to bring supported operational data sources such as Cosmos DB into Fabric for low-latency analytics. That fits better than report-layer features.', 'Mirroring ist dafür gedacht, unterstützte operative Datenquellen wie Cosmos DB für Analysen mit geringer Latenz nach Fabric zu bringen. Das passt besser als Berichtsebene-Funktionen.'),
      t('Focus on data replication, not report authoring.', 'Konzentrieren Sie sich auf Datenreplikation und nicht auf Berichtserstellung.'),
      ref.mirroring),

    q('dp700-150', 'single', prepare, 'medium',
      t('Data engineers need open files and Delta tables, Spark notebooks, and a SQL surface over the same data for analysts.', 'Data Engineers benötigen offene Dateien und Delta-Tabellen, Spark-Notebooks und eine SQL-Oberfläche über denselben Daten für Analysten.'),
      t('Which Fabric item is the best primary choice?', 'Welches Fabric-Element ist die beste primäre Wahl?'),
      [
        o('A', 'Lakehouse', 'Lakehouse'),
        o('B', 'Paginated report', 'Paginierter Bericht'),
        o('C', 'Dashboard', 'Dashboard'),
        o('D', 'Workspace domain', 'Arbeitsbereichsdomäne')
      ],
      ['A'],
      t('A lakehouse supports open-file storage, Delta tables, Spark engineering, and a SQL analytics endpoint against the same curated data. This combination matches the scenario closely.', 'Ein Lakehouse unterstützt offene Dateispeicherung, Delta-Tabellen, Spark-Engineering und einen SQL-Analyseendpunkt gegen dieselben kuratierten Daten. Diese Kombination entspricht dem Szenario sehr genau.'),
      t('One store, multiple access patterns.', 'Ein Speicher, mehrere Zugriffsmuster.'),
      ref.lakehouse),

    q('dp700-151', 'single', prepare, 'medium', null,
      t('Which Fabric item is the strongest fit when the solution centers on T-SQL modeling, views, procedures, and serving a relational star schema to BI consumers?', 'Welches Fabric-Element passt am besten, wenn sich die Lösung auf T-SQL-Modellierung, Views, Prozeduren und die Bereitstellung eines relationalen Sternschemas für BI-Verbraucher konzentriert?'),
      [
        o('A', 'Warehouse', 'Warehouse'),
        o('B', 'Eventstream', 'Eventstream'),
        o('C', 'OneLake shortcut', 'OneLake-Shortcut'),
        o('D', 'Notebook markdown cell', 'Markdown-Zelle im Notebook')
      ],
      ['A'],
      t('A Fabric warehouse is optimized for relational analytics with T-SQL authoring and dimensional serving patterns. It is the natural fit for warehouse-style BI preparation.', 'Ein Fabric Warehouse ist für relationale Analytik mit T-SQL-Entwicklung und dimensionalen Bereitstellungsmustern optimiert. Es ist die natürliche Wahl für warehouseartige BI-Vorbereitung.'),
      t('Choose the relational serving engine.', 'Wählen Sie die relationale Bereitstellungs-Engine.'),
      ref.warehouse),

    q('dp700-152', 'single', prepare, 'medium',
      t('A data engineering team wants a repeatable, schedulable code item for Spark batch jobs that can run packaged binaries or scripts with arguments.', 'Ein Data-Engineering-Team möchte ein wiederholbares, planbares Codeelement für Spark-Batchjobs, das verpackte Binärdateien oder Skripte mit Argumenten ausführen kann.'),
      t('Which Fabric item should they use?', 'Welches Fabric-Element sollten sie verwenden?'),
      [
        o('A', 'Spark job definition', 'Spark-Jobdefinition'),
        o('B', 'Bookmark', 'Lesezeichen'),
        o('C', 'Q&A', 'Q&A'),
        o('D', 'OLS role', 'OLS-Rolle')
      ],
      ['A'],
      t('Spark job definitions are intended for repeatable Spark batch and streaming jobs, including packaged artifacts and arguments. They are better suited to productionized job execution than ad hoc report features.', 'Spark-Jobdefinitionen sind für wiederholbare Spark-Batch- und Streamingjobs vorgesehen, einschließlich verpackter Artefakte und Argumente. Sie eignen sich besser für produktionsnahe Jobausführung als Ad-hoc-Berichtsfunktionen.'),
      t('Think production-oriented Spark execution.', 'Denken Sie an produktionsorientierte Spark-Ausführung.'),
      ref.sparkJobs),

    q('dp700-153', 'single', prepare, 'hard',
      t('A Delta table contains billions of rows. Most queries filter by Country and Year, but Country has only a few dozen values while TransactionId is unique.', 'Eine Delta-Tabelle enthält Milliarden von Zeilen. Die meisten Abfragen filtern nach Country und Year, aber Country hat nur einige Dutzend Werte, während TransactionId eindeutig ist.'),
      t('Which partitioning approach is generally more sensible?', 'Welcher Partitionierungsansatz ist in der Regel sinnvoller?'),
      [
        o('A', 'Partition by a commonly filtered low-cardinality column such as Country or Year', 'Partitionieren Sie nach einer häufig gefilterten Spalte mit niedriger Kardinalität wie Country oder Year'),
        o('B', 'Partition by TransactionId because it is unique', 'Partitionieren Sie nach TransactionId, weil sie eindeutig ist'),
        o('C', 'Disable partitioning for all large tables', 'Deaktivieren Sie Partitionierung für alle großen Tabellen'),
        o('D', 'Partition by workspace role', 'Partitionieren Sie nach Arbeitsbereichsrolle')
      ],
      ['A'],
      t('Partitioning usually works best on columns that align with common filters and do not create excessive fragmentation. Very high-cardinality columns such as unique IDs are typically poor partition choices.', 'Partitionierung funktioniert in der Regel am besten bei Spalten, die häufigen Filtern entsprechen und keine übermäßige Fragmentierung erzeugen. Sehr hoch kardinale Spalten wie eindeutige IDs sind typischerweise schlechte Partitionierungsoptionen.'),
      t('Avoid partitions that explode into too many tiny slices.', 'Vermeiden Sie Partitionen, die in zu viele kleine Segmente zerfallen.'),
      ref.delta),

    q('dp700-154', 'single', prepare, 'medium', null,
      t('A new nullable column appears in source data, and the target Delta table should accept it without a full table rebuild. Which concept is relevant?', 'Eine neue nullable Spalte erscheint in den Quelldaten, und die Ziel-Delta-Tabelle soll sie ohne vollständigen Neuaufbau akzeptieren. Welches Konzept ist relevant?'),
      [
        o('A', 'Schema evolution', 'Schemaevolution'),
        o('B', 'Bookmark capture', 'Lesezeichenerfassung'),
        o('C', 'Cross-highlighting', 'Kreuzhervorhebung'),
        o('D', 'Tenant settings', 'Mandanteneinstellungen')
      ],
      ['A'],
      t('Delta tables support schema evolution scenarios so pipelines can accommodate certain source changes without rebuilding everything manually. This is useful when new columns arrive over time.', 'Delta-Tabellen unterstützen Szenarien zur Schemaevolution, sodass Pipelines bestimmte Quelländerungen aufnehmen können, ohne alles manuell neu aufzubauen. Das ist nützlich, wenn im Laufe der Zeit neue Spalten hinzukommen.'),
      t('Think about controlled adaptation of the table schema.', 'Denken Sie an die kontrollierte Anpassung des Tabellenschemas.'),
      ref.delta),

    q('dp700-155', 'single', prepare, 'medium',
      t('A warehouse dimension must be updated nightly so changed customers are updated and new customers are inserted in one step.', 'Eine Warehouse-Dimension muss jede Nacht aktualisiert werden, sodass geänderte Kunden aktualisiert und neue Kunden in einem Schritt eingefügt werden.'),
      t('Which T-SQL pattern is most suitable?', 'Welches T-SQL-Muster ist am geeignetsten?'),
      [
        o('A', 'MERGE', 'MERGE'),
        o('B', 'Bookmark', 'Lesezeichen'),
        o('C', 'Q&A', 'Q&A'),
        o('D', 'VACUUM', 'VACUUM')
      ],
      ['A'],
      t('MERGE is a standard pattern for upsert logic because it can update matched rows and insert new ones in one statement. That is a common dimension maintenance scenario.', 'MERGE ist ein Standardmuster für Upsert-Logik, weil es passende Zeilen aktualisieren und neue in einer Anweisung einfügen kann. Das ist ein häufiges Szenario für die Pflege von Dimensionen.'),
      t('One statement for inserts and updates.', 'Eine Anweisung für Inserts und Updates.'),
      ref.warehouse),

    q('dp700-156', 'single', prepare, 'easy', null,
      t('Why would you create a SQL view in a Fabric warehouse?', 'Warum würden Sie in einem Fabric Warehouse eine SQL-View erstellen?'),
      [
        o('A', 'To encapsulate reusable query logic for consumers', 'Um wiederverwendbare Abfragelogik für Verbraucher zu kapseln'),
        o('B', 'To schedule capacity scaling', 'Um Kapazitätsskalierung zu planen'),
        o('C', 'To grant admin rights automatically', 'Um automatisch Administratorrechte zu vergeben'),
        o('D', 'To turn a report into a notebook', 'Um einen Bericht in ein Notebook umzuwandeln')
      ],
      ['A'],
      t('Views provide a reusable SQL abstraction over underlying tables and can simplify analyst access to curated relational logic. They do not replace governance or capacity tools.', 'Views bieten eine wiederverwendbare SQL-Abstraktion über zugrunde liegende Tabellen und können Analysten den Zugriff auf kuratierte relationale Logik vereinfachen. Sie ersetzen weder Governance- noch Kapazitätswerkzeuge.'),
      t('Choose the reusable relational abstraction.', 'Wählen Sie die wiederverwendbare relationale Abstraktion.'),
      ref.warehouse),

    q('dp700-157', 'single', prepare, 'hard',
      t('A developer wants one T-SQL query that joins a warehouse dimension to a table exposed through a lakehouse SQL analytics endpoint in the same workspace.', 'Ein Entwickler möchte eine einzige T-SQL-Abfrage, die eine Warehouse-Dimension mit einer Tabelle verknüpft, die über den SQL-Analyseendpunkt eines Lakehouse im selben Arbeitsbereich verfügbar ist.'),
      t('What Fabric capability enables this pattern?', 'Welche Fabric-Fähigkeit ermöglicht dieses Muster?'),
      [
        o('A', 'Cross-database or cross-warehouse querying in the SQL editor', 'Cross-Database- bzw. Cross-Warehouse-Abfragen im SQL-Editor'),
        o('B', 'Bookmark synchronization', 'Lesezeichensynchronisierung'),
        o('C', 'Report drillthrough', 'Berichts-Drillthrough'),
        o('D', 'DAX time intelligence', 'DAX-Time-Intelligence')
      ],
      ['A'],
      t('Fabric SQL supports cross-item querying within the same workspace, letting you combine warehouse and SQL endpoint data in a single T-SQL statement. This is a data-serving capability, not a report feature.', 'Fabric SQL unterstützt Cross-Item-Abfragen innerhalb desselben Arbeitsbereichs und erlaubt so, Warehouse- und SQL-Endpunkt-Daten in einer einzigen T-SQL-Anweisung zu kombinieren. Dies ist eine Datenbereitstellungsfunktion und keine Berichtsfunktion.'),
      t('Think one SQL statement across multiple Fabric SQL items.', 'Denken Sie an eine SQL-Anweisung über mehrere Fabric-SQL-Elemente hinweg.'),
      ref.crossWarehouse),

    q('dp700-158', 'single', prepare, 'hard',
      t('An engineer needs a point-in-time copy of a warehouse table from two days ago to investigate a data issue.', 'Ein Engineer benötigt eine Point-in-Time-Kopie einer Warehouse-Tabelle von vor zwei Tagen, um ein Datenproblem zu untersuchen.'),
      t('Which capability is designed for this?', 'Welche Funktion ist dafür gedacht?'),
      [
        o('A', 'Table clone using point-in-time history', 'Tabellenklon mit Point-in-Time-Historie'),
        o('B', 'Bookmark with current filters', 'Lesezeichen mit aktuellen Filtern'),
        o('C', 'Q&A synonym list', 'Q&A-Synonymliste'),
        o('D', 'Shortcut to a PDF export', 'Shortcut zu einem PDF-Export')
      ],
      ['A'],
      t('Fabric table cloning supports creating a clone from a prior point in time within retention. That is useful for investigation, testing, and recovery scenarios.', 'Fabric-Tabellenklon unterstützt die Erstellung eines Klons aus einem früheren Zeitpunkt innerhalb der Aufbewahrungszeit. Das ist nützlich für Untersuchungs-, Test- und Recovery-Szenarien.'),
      t('Look for the warehouse feature with point-in-time copy behavior.', 'Suchen Sie nach der Warehouse-Funktion mit Point-in-Time-Kopieverhalten.'),
      ref.clone),

    q('dp700-159', 'single', prepare, 'medium', null,
      t('Which statement best describes Dataflows Gen2 destinations?', 'Welche Aussage beschreibt Ziele von Dataflows Gen2 am besten?'),
      [
        o('A', 'They can write transformed results to Fabric targets such as lakehouses or warehouses', 'Sie können transformierte Ergebnisse in Fabric-Ziele wie Lakehouses oder Warehouses schreiben'),
        o('B', 'They can write only to bookmarks', 'Sie können nur in Lesezeichen schreiben'),
        o('C', 'They can never be orchestrated by pipelines', 'Sie können niemals durch Pipelines orchestriert werden'),
        o('D', 'They replace the Fabric admin center', 'Sie ersetzen das Fabric Admin Center')
      ],
      ['A'],
      t('Dataflows Gen2 are not only about shaping data. They can also load outputs into Fabric storage and serving items, making them practical for low-code preparation pipelines.', 'Dataflows Gen2 dienen nicht nur der Datenaufbereitung. Sie können Ausgaben auch in Fabric-Speicher- und Bereitstellungselemente laden, was sie für Low-Code-Vorbereitungspipelines praktisch macht.'),
      t('Think transformation plus load destination.', 'Denken Sie an Transformation plus Ladeziel.'),
      ref.dataflows),

    q('dp700-160', 'single', prepare, 'medium',
      t('A logistics team wants live package events sent to Fabric and needs the stream filtered so only delayed shipments are written to the destination.', 'Ein Logistikteam möchte Live-Paketereignisse an Fabric senden und benötigt eine Filterung des Streams, sodass nur verspätete Sendungen in das Ziel geschrieben werden.'),
      t('Which Fabric item should be central to this solution?', 'Welches Fabric-Element sollte in dieser Lösung zentral sein?'),
      [
        o('A', 'Eventstream', 'Eventstream'),
        o('B', 'Bookmark', 'Lesezeichen'),
        o('C', 'OLS role', 'OLS-Rolle'),
        o('D', 'Paginated report', 'Paginierter Bericht')
      ],
      ['A'],
      t('Eventstream is designed to ingest, optionally transform, and route real-time events to destinations. It fits scenarios where filtering and routing of live events is needed.', 'Eventstream ist dafür ausgelegt, Echtzeitereignisse aufzunehmen, optional zu transformieren und an Ziele weiterzuleiten. Es passt zu Szenarien, in denen Live-Ereignisse gefiltert und geroutet werden müssen.'),
      t('Choose the item made for real-time event routing.', 'Wählen Sie das Element, das für das Routing von Echtzeitereignissen gedacht ist.'),
      ref.eventstream),

    q('dp700-161', 'single', semantic, 'medium',
      t('A semantic model must query very large OneLake Delta tables with minimal duplication while still giving users near-import performance.', 'Ein semantisches Modell muss sehr große OneLake-Delta-Tabellen mit minimaler Duplizierung abfragen und den Benutzern dennoch nahezu Import-Leistung bieten.'),
      t('Which storage mode is the best fit?', 'Welcher Speichermodus passt am besten?'),
      [
        o('A', 'Direct Lake', 'Direct Lake'),
        o('B', 'Live connection to bookmarks', 'Liveverbindung zu Lesezeichen'),
        o('C', 'CSV mode', 'CSV-Modus'),
        o('D', 'Report page mode', 'Berichtsseitenmodus')
      ],
      ['A'],
      t('Direct Lake is designed for querying OneLake data directly with very fast interactive performance and less duplication than classic import. It is a natural fit for large Fabric-backed semantic models.', 'Direct Lake ist dafür ausgelegt, OneLake-Daten direkt mit sehr schneller interaktiver Leistung und weniger Duplizierung als beim klassischen Import abzufragen. Er ist eine natürliche Wahl für große, durch Fabric unterstützte semantische Modelle.'),
      t('Think OneLake-native analytics with minimal copies.', 'Denken Sie an OneLake-native Analytik mit minimalen Kopien.'),
      ref.directLake),

    q('dp700-162', 'single', semantic, 'hard',
      t('A model must import historical sales for fast slicing, but current inventory must stay in DirectQuery against an operational source because it changes every few minutes.', 'Ein Modell muss historische Verkäufe importieren, um schnelles Filtern zu ermöglichen, aber der aktuelle Bestand muss im DirectQuery-Modus gegen eine operative Quelle bleiben, weil er sich alle paar Minuten ändert.'),
      t('Which model design best supports this?', 'Welches Modelldesign unterstützt dies am besten?'),
      [
        o('A', 'Composite model', 'Kompositmodell'),
        o('B', 'Bookmark collection', 'Lesezeichensammlung'),
        o('C', 'Paginated report only', 'Nur paginierter Bericht'),
        o('D', 'OLS without relationships', 'OLS ohne Beziehungen')
      ],
      ['A'],
      t('Composite models let different tables use different storage behaviors, such as import for stable historical data and DirectQuery for fast-changing operational data. This balances performance and freshness.', 'Kompositmodelle erlauben es, für unterschiedliche Tabellen verschiedene Speicherverhalten zu verwenden, etwa Import für stabile historische Daten und DirectQuery für sich schnell ändernde operative Daten. Das balanciert Leistung und Aktualität.'),
      t('Look for a design that mixes storage modes in one model.', 'Suchen Sie nach einem Design, das Speichermodi in einem Modell mischt.'),
      ref.directLake),

    q('dp700-163', 'single', semantic, 'medium', null,
      t('What is the primary role of CALCULATE in DAX?', 'Was ist die primäre Rolle von CALCULATE in DAX?'),
      [
        o('A', 'Modify filter context before evaluating an expression', 'Den Filterkontext ändern, bevor ein Ausdruck ausgewertet wird'),
        o('B', 'Create workspace roles', 'Arbeitsbereichsrollen erstellen'),
        o('C', 'Load data into OneLake', 'Daten in OneLake laden'),
        o('D', 'Configure tenant settings', 'Mandanteneinstellungen konfigurieren')
      ],
      ['A'],
      t('CALCULATE is central to DAX because it evaluates an expression in a modified filter context. Many advanced measures rely on it for scoped filtering and time intelligence patterns.', 'CALCULATE ist zentral in DAX, weil es einen Ausdruck in einem geänderten Filterkontext auswertet. Viele fortgeschrittene Measures verlassen sich darauf für gefilterte Auswertung und Time-Intelligence-Muster.'),
      t('Think expression plus changed filters.', 'Denken Sie an Ausdruck plus geänderte Filter.'),
      ref.daxCalculate),

    q('dp700-164', 'single', semantic, 'hard',
      t('Each sales row stores Quantity and UnitPrice. You need a measure that sums Quantity multiplied by UnitPrice across all visible rows.', 'Jede Verkaufszeile speichert Quantity und UnitPrice. Sie benötigen eine Measure, die Quantity multipliziert mit UnitPrice über alle sichtbaren Zeilen summiert.'),
      t('Which DAX pattern is the best fit?', 'Welches DAX-Muster ist am besten geeignet?'),
      [
        o('A', 'SUMX over the sales table', 'SUMX über die Verkaufstabelle'),
        o('B', 'COUNTROWS over the date table', 'COUNTROWS über die Datumstabelle'),
        o('C', 'USERELATIONSHIP alone', 'Nur USERELATIONSHIP'),
        o('D', 'Bookmark navigation', 'Lesezeichennavigation')
      ],
      ['A'],
      t('SUMX is an iterator that evaluates an expression row by row and then sums the results. It is a common pattern for line amount calculations such as Quantity times UnitPrice.', 'SUMX ist eine Iteratorfunktion, die einen Ausdruck Zeile für Zeile auswertet und die Ergebnisse anschließend summiert. Sie ist ein gängiges Muster für Positionsbeträge wie Quantity mal UnitPrice.'),
      t('Think row-by-row calculation followed by a sum.', 'Denken Sie an zeilenweise Berechnung mit anschließender Summe.'),
      ref.daxSumx),

    q('dp700-165', 'single', semantic, 'medium', null,
      t('Why are DAX variables often useful in complex measures?', 'Warum sind DAX-Variablen in komplexen Measures oft nützlich?'),
      [
        o('A', 'They improve readability and let you reuse intermediate results', 'Sie verbessern die Lesbarkeit und erlauben die Wiederverwendung von Zwischenergebnissen'),
        o('B', 'They replace all model relationships', 'Sie ersetzen alle Modellbeziehungen'),
        o('C', 'They force DirectQuery mode', 'Sie erzwingen den DirectQuery-Modus'),
        o('D', 'They turn a semantic model into a warehouse', 'Sie verwandeln ein semantisches Modell in ein Warehouse')
      ],
      ['A'],
      t('Variables make measures easier to read and maintain because you can name intermediate logic and reference it later in the formula. This often reduces repetition and mistakes.', 'Variablen machen Measures leichter lesbar und wartbar, weil Sie Zwischenschritte benennen und später in der Formel referenzieren können. Das reduziert oft Wiederholungen und Fehler.'),
      t('Think cleaner formulas with reusable intermediate values.', 'Denken Sie an sauberere Formeln mit wiederverwendbaren Zwischenwerten.'),
      ref.daxVar),

    q('dp700-166', 'single', semantic, 'hard',
      t('A Sales table relates to Date by OrderDate as the active relationship, but a report page must analyze sales by ShipDate without changing the default model behavior elsewhere.', 'Eine Sales-Tabelle ist über OrderDate mit Date als aktive Beziehung verknüpft, aber eine Berichtsseite muss Verkäufe nach ShipDate analysieren, ohne das Standardverhalten des Modells an anderer Stelle zu ändern.'),
      t('What is the best DAX technique?', 'Welche DAX-Technik ist die beste?'),
      [
        o('A', 'Use USERELATIONSHIP inside the relevant measure', 'Verwenden Sie USERELATIONSHIP innerhalb der betreffenden Measure'),
        o('B', 'Delete the active relationship', 'Löschen Sie die aktive Beziehung'),
        o('C', 'Replace the Date table with bookmarks', 'Ersetzen Sie die Datumstabelle durch Lesezeichen'),
        o('D', 'Use VACUUM on the model', 'Verwenden Sie VACUUM auf dem Modell')
      ],
      ['A'],
      t('USERELATIONSHIP lets a measure temporarily activate an inactive relationship for that calculation only. This is ideal when a table has multiple valid date roles such as order date and ship date.', 'USERELATIONSHIP ermöglicht es einer Measure, für genau diese Berechnung temporär eine inaktive Beziehung zu aktivieren. Das ist ideal, wenn eine Tabelle mehrere gültige Datumsrollen wie Bestelldatum und Versanddatum hat.'),
      t('Use the inactive relationship only where you need it.', 'Verwenden Sie die inaktive Beziehung nur dort, wo Sie sie benötigen.'),
      ref.daxUserRelationship),

    q('dp700-167', 'single', semantic, 'medium', null,
      t('Why should bidirectional filtering be used carefully in semantic models?', 'Warum sollte bidirektionale Filterung in semantischen Modellen mit Vorsicht verwendet werden?'),
      [
        o('A', 'It can introduce ambiguous filter paths and unexpected results', 'Sie kann zu mehrdeutigen Filterpfaden und unerwarteten Ergebnissen führen'),
        o('B', 'It is required for every star schema', 'Sie ist für jedes Sternschema erforderlich'),
        o('C', 'It disables all DAX measures', 'Sie deaktiviert alle DAX-Measures'),
        o('D', 'It turns Import mode into DirectQuery automatically', 'Sie verwandelt den Importmodus automatisch in DirectQuery')
      ],
      ['A'],
      t('Bidirectional filters can solve specific modeling problems, but they also increase complexity and the risk of ambiguous propagation. Single-direction filtering is often more predictable in star schemas.', 'Bidirektionale Filter können bestimmte Modellierungsprobleme lösen, erhöhen aber auch die Komplexität und das Risiko mehrdeutiger Ausbreitung. Einseitige Filterung ist in Sternschemata oft besser vorhersagbar.'),
      t('Think about ambiguity and unexpected filter propagation.', 'Denken Sie an Mehrdeutigkeit und unerwartete Filterausbreitung.'),
      ref.relationships),

    q('dp700-168', 'single', semantic, 'medium', null,
      t('What is a common modeling approach for a role-playing date dimension when users need separate Order Date and Ship Date slicers?', 'Welcher Modellierungsansatz ist bei einer Rollenspiel-Datumsdimension üblich, wenn Benutzer separate Slicer für Bestell- und Versanddatum benötigen?'),
      [
        o('A', 'Use separate date table roles or explicit inactive relationships depending on the design', 'Verwenden Sie separate Rollen der Datumstabelle oder explizite inaktive Beziehungen je nach Design'),
        o('B', 'Remove the date dimension completely', 'Entfernen Sie die Datumstabelle vollständig'),
        o('C', 'Replace the dates with bookmarks', 'Ersetzen Sie die Daten durch Lesezeichen'),
        o('D', 'Store both dates only in report titles', 'Speichern Sie beide Daten nur in Berichtstiteln')
      ],
      ['A'],
      t('Role-playing dimensions are handled either by separate copies of the dimension or by carefully managed inactive relationships with measures. Both patterns make the date role explicit to report authors.', 'Rollenspiel-Dimensionen werden entweder durch separate Kopien der Dimension oder durch sorgfältig verwaltete inaktive Beziehungen mit Measures behandelt. Beide Muster machen die Datumsrolle für Berichtsautoren explizit.'),
      t('The model needs distinct date roles, not fewer dates.', 'Das Modell benötigt unterschiedliche Datumsrollen und nicht weniger Daten.'),
      ref.relationships),

    q('dp700-169', 'multiple', semantic, 'hard',
      t('Regional managers must see only their own region in reports, while executives must see all regions by using the same semantic model.', 'Regionale Manager dürfen in Berichten nur ihre eigene Region sehen, während Führungskräfte mit demselben semantischen Modell alle Regionen sehen müssen.'),
      t('Which two statements are correct?', 'Welche zwei Aussagen sind korrekt?'),
      [
        o('A', 'Dynamic RLS can use a mapping table and USERPRINCIPALNAME to filter by signed-in user', 'Dynamische RLS kann eine Zuordnungstabelle und USERPRINCIPALNAME verwenden, um nach angemeldetem Benutzer zu filtern'),
        o('B', 'Static RLS means every user automatically gets a different region without defined roles', 'Statische RLS bedeutet, dass jeder Benutzer automatisch eine andere Region ohne definierte Rollen erhält'),
        o('C', 'Executives can be assigned to a role that does not filter regions', 'Führungskräfte können einer Rolle zugewiesen werden, die Regionen nicht filtert'),
        o('D', 'Bookmarks are the recommended security boundary for row filtering', 'Lesezeichen sind die empfohlene Sicherheitsgrenze für Zeilenfilterung')
      ],
      ['A', 'C'],
      t('Dynamic RLS supports per-user filtering with a mapping table, while a separate unfiltered role can be used for executives. Bookmarks do not enforce data security.', 'Dynamische RLS unterstützt die benutzerspezifische Filterung mit einer Zuordnungstabelle, während für Führungskräfte eine separate ungefilterte Rolle verwendet werden kann. Lesezeichen erzwingen keine Datensicherheit.'),
      t('Use model security roles, not visual tricks.', 'Verwenden Sie Modellsicherheitsrollen und keine visuellen Tricks.'),
      ref.rls),

    q('dp700-170', 'single', semantic, 'medium', null,
      t('What does object-level security add beyond row-level security?', 'Was ergänzt Object-Level-Security über Row-Level-Security hinaus?'),
      [
        o('A', 'It can hide entire tables or columns from unauthorized viewers', 'Sie kann ganze Tabellen oder Spalten vor nicht berechtigten Betrachtern verbergen'),
        o('B', 'It partitions import data automatically', 'Sie partitioniert Importdaten automatisch'),
        o('C', 'It schedules notebook jobs', 'Sie plant Notebook-Jobs'),
        o('D', 'It creates new workspaces', 'Sie erstellt neue Arbeitsbereiche')
      ],
      ['A'],
      t('OLS is used to restrict visibility of tables or columns, while RLS filters rows. They solve different security problems and can be combined.', 'OLS wird verwendet, um die Sichtbarkeit von Tabellen oder Spalten einzuschränken, während RLS Zeilen filtert. Sie lösen unterschiedliche Sicherheitsprobleme und können kombiniert werden.'),
      t('RLS filters rows; OLS hides objects.', 'RLS filtert Zeilen, OLS verbirgt Objekte.'),
      ref.ols),

    q('dp700-171', 'single', semantic, 'medium',
      t('A BI team builds semantic models in a development workspace, validates them in test, and then promotes approved content to production.', 'Ein BI-Team erstellt semantische Modelle in einem Entwicklungsarbeitsbereich, validiert sie in Test und überführt freigegebene Inhalte anschließend nach Produktion.'),
      t('Which Fabric feature supports this lifecycle best?', 'Welche Fabric-Funktion unterstützt diesen Lebenszyklus am besten?'),
      [
        o('A', 'Deployment pipelines', 'Deployment-Pipelines'),
        o('B', 'Q&A tooling', 'Q&A-Tools'),
        o('C', 'VACUUM', 'VACUUM'),
        o('D', 'Bookmark groups', 'Lesezeichengruppen')
      ],
      ['A'],
      t('Deployment pipelines are designed for controlled promotion of content through stages such as development, test, and production. This supports governance and repeatable release processes.', 'Deployment-Pipelines sind für die kontrollierte Überführung von Inhalten durch Stufen wie Entwicklung, Test und Produktion vorgesehen. Das unterstützt Governance und wiederholbare Release-Prozesse.'),
      t('Choose the feature made for staged promotion.', 'Wählen Sie die Funktion, die für gestufte Überführung gedacht ist.'),
      ref.deployment),

    q('dp700-172', 'single', semantic, 'medium', null,
      t('Which setting is important when a Fabric semantic model must exceed the default 1 GB size limit?', 'Welche Einstellung ist wichtig, wenn ein semantisches Fabric-Modell die Standardgrößengrenze von 1 GB überschreiten muss?'),
      [
        o('A', 'Large semantic model storage format', 'Speicherformat für große semantische Modelle'),
        o('B', 'Bookmark storage format', 'Speicherformat für Lesezeichen'),
        o('C', 'Workspace domain inheritance', 'Domänenvererbung im Arbeitsbereich'),
        o('D', 'Q&A storage format', 'Speicherformat für Q&A')
      ],
      ['A'],
      t('Large semantic model storage format is the setting that allows models on appropriate Fabric capacity to exceed the default size limit. It is relevant for large enterprise models.', 'Das Speicherformat für große semantische Modelle ist die Einstellung, die es Modellen auf geeigneter Fabric-Kapazität erlaubt, die Standardgrößengrenze zu überschreiten. Es ist für große Unternehmensmodelle relevant.'),
      t('Think of the explicit setting for larger model capacity.', 'Denken Sie an die explizite Einstellung für größere Modellkapazität.'),
      ref.largeModels),

    q('dp700-173', 'single', semantic, 'medium',
      t('A semantic model contains ten years of fact data, but only the most recent months change regularly. Refreshing the full model takes too long.', 'Ein semantisches Modell enthält Faktendaten aus zehn Jahren, aber nur die letzten Monate ändern sich regelmäßig. Die vollständige Aktualisierung des Modells dauert zu lange.'),
      t('What should you implement?', 'Was sollten Sie implementieren?'),
      [
        o('A', 'Incremental refresh', 'Inkrementelle Aktualisierung'),
        o('B', 'Bookmark navigator', 'Lesezeichen-Navigator'),
        o('C', 'Eventstream', 'Eventstream'),
        o('D', 'Workspace role inheritance', 'Vererbung von Arbeitsbereichsrollen')
      ],
      ['A'],
      t('Incremental refresh partitions data and refreshes only the range that changes, which can dramatically reduce refresh duration for large historical models.', 'Die inkrementelle Aktualisierung partitioniert Daten und aktualisiert nur den Bereich, der sich ändert. Dadurch kann sich die Dauer der Aktualisierung bei großen historischen Modellen stark verringern.'),
      t('Refresh the changing partitions, not the entire history.', 'Aktualisieren Sie die sich ändernden Partitionen und nicht die gesamte Historie.'),
      ref.incremental),

    q('dp700-174', 'multiple', semantic, 'hard',
      t('A very large DirectQuery fact table serves dashboards that usually query monthly totals by Product and Region. Detail drillthrough still needs to work on demand.', 'Eine sehr große DirectQuery-Faktentabelle bedient Dashboards, die in der Regel monatliche Summen nach Produkt und Region abfragen. Detail-Drillthrough muss bei Bedarf trotzdem funktionieren.'),
      t('Which two techniques are most relevant?', 'Welche zwei Techniken sind am relevantesten?'),
      [
        o('A', 'Create an aggregation table at the higher grain', 'Erstellen Sie eine Aggregationstabelle auf höherer Granularität'),
        o('B', 'Map model aggregations so summary queries can hit the aggregated cache', 'Ordnen Sie Modellaggregationen zu, damit Zusammenfassungsabfragen den aggregierten Cache nutzen können'),
        o('C', 'Delete the detail table permanently', 'Löschen Sie die Detailtabelle dauerhaft'),
        o('D', 'Replace relationships with bookmarks', 'Ersetzen Sie Beziehungen durch Lesezeichen')
      ],
      ['A', 'B'],
      t('Aggregations improve performance when common summary queries can be answered from pre-aggregated data, while detail queries can still fall back to the lower-grain table. This balances speed and fidelity.', 'Aggregationen verbessern die Leistung, wenn häufige Zusammenfassungsabfragen aus voraggregierten Daten beantwortet werden können, während Detailabfragen weiterhin auf die Tabelle mit niedrigerer Granularität zurückfallen. Das balanciert Geschwindigkeit und Genauigkeit.'),
      t('Use a higher-grain cache without losing access to details.', 'Verwenden Sie einen Cache höherer Granularität, ohne den Zugriff auf Details zu verlieren.'),
      ref.aggregations),

    q('dp700-175', 'single', semantic, 'hard',
      t('A model contains dozens of nearly identical time-intelligence measures such as MTD, QTD, and YTD for many base measures. Maintenance is becoming difficult.', 'Ein Modell enthält Dutzende fast identische Time-Intelligence-Measures wie MTD, QTD und YTD für viele Basis-Measures. Die Wartung wird schwierig.'),
      t('Which feature should you evaluate?', 'Welche Funktion sollten Sie prüfen?'),
      [
        o('A', 'Calculation groups', 'Berechnungsgruppen'),
        o('B', 'Workspace domains', 'Arbeitsbereichsdomänen'),
        o('C', 'OneLake shortcuts', 'OneLake-Shortcuts'),
        o('D', 'Eventstream filters', 'Eventstream-Filter')
      ],
      ['A'],
      t('Calculation groups reduce repeated measure patterns by centralizing reusable calculation logic such as time intelligence. This can greatly simplify model maintenance.', 'Berechnungsgruppen reduzieren wiederholte Measure-Muster, indem wiederverwendbare Berechnungslogik wie Time Intelligence zentralisiert wird. Das kann die Wartung des Modells erheblich vereinfachen.'),
      t('Think reusable calculation logic instead of many cloned measures.', 'Denken Sie an wiederverwendbare Berechnungslogik statt an viele geklonte Measures.'),
      ref.calcGroups),

    q('dp700-176', 'single', semantic, 'medium', null,
      t('Which modeling technique commonly resolves a many-to-many business relationship while keeping measures reliable?', 'Welche Modellierungstechnik löst häufig eine geschäftliche Viele-zu-viele-Beziehung und hält Measures dabei zuverlässig?'),
      [
        o('A', 'Use a bridge table and model the relationship paths carefully', 'Verwenden Sie eine Brückentabelle und modellieren Sie die Beziehungspfade sorgfältig'),
        o('B', 'Remove all relationships', 'Entfernen Sie alle Beziehungen'),
        o('C', 'Use bookmarks instead of dimensions', 'Verwenden Sie Lesezeichen statt Dimensionen'),
        o('D', 'Store all data in report tooltips', 'Speichern Sie alle Daten in Berichtstooltips')
      ],
      ['A'],
      t('A bridge table is a common way to model many-to-many scenarios in a controlled way. It provides a clear path for filter propagation and business logic.', 'Eine Brückentabelle ist eine gängige Methode, um Viele-zu-viele-Szenarien kontrolliert zu modellieren. Sie bietet einen klaren Pfad für Filterweitergabe und Geschäftslogik.'),
      t('Look for the structured modeling solution, not a visual workaround.', 'Suchen Sie nach der strukturierten Modelllösung und nicht nach einer visuellen Umgehung.'),
      ref.relationships),

    q('dp700-177', 'single', semantic, 'medium', null,
      t('What is a main tradeoff of Import mode in a semantic model compared to DirectQuery?', 'Was ist ein wesentlicher Zielkonflikt des Importmodus in einem semantischen Modell im Vergleich zu DirectQuery?'),
      [
        o('A', 'It often gives faster interactive performance but requires refresh to pick up source changes', 'Er bietet oft schnellere interaktive Leistung, erfordert aber Aktualisierungen, um Quelländerungen zu übernehmen'),
        o('B', 'It can never use DAX', 'Er kann niemals DAX verwenden'),
        o('C', 'It removes the need for relationships', 'Er macht Beziehungen überflüssig'),
        o('D', 'It is only for paginated reports', 'Er ist nur für paginierte Berichte gedacht')
      ],
      ['A'],
      t('Import mode stores data in the semantic model for fast query performance, but the cached data must be refreshed to reflect source changes. That is the central freshness tradeoff.', 'Der Importmodus speichert Daten für schnelle Abfrageleistung im semantischen Modell, aber die zwischengespeicherten Daten müssen aktualisiert werden, um Quelländerungen widerzuspiegeln. Das ist der zentrale Zielkonflikt bei der Aktualität.'),
      t('Fast cache versus source freshness.', 'Schneller Cache versus Quellaktualität.'),
      ref.directLake),

    q('dp700-178', 'single', semantic, 'medium',
      t('A report author wants to build a composite model that references a shared enterprise semantic model and also adds a local table for what-if analysis.', 'Ein Berichtsautor möchte ein Kompositmodell erstellen, das auf ein gemeinsames semantisches Unternehmensmodell verweist und zusätzlich eine lokale Tabelle für Was-wäre-wenn-Analysen ergänzt.'),
      t('What is the main advantage of this approach?', 'Was ist der Hauptvorteil dieses Ansatzes?'),
      [
        o('A', 'It reuses centralized enterprise logic while allowing limited local extension', 'Es nutzt zentralisierte Unternehmenslogik wieder und erlaubt gleichzeitig eine begrenzte lokale Erweiterung'),
        o('B', 'It removes the need for any governance', 'Es macht jede Governance überflüssig'),
        o('C', 'It replaces all source systems', 'Es ersetzt alle Quellsysteme'),
        o('D', 'It turns Power BI into a data pipeline', 'Es verwandelt Power BI in eine Datenpipeline')
      ],
      ['A'],
      t('Composite models can extend governed semantic models with local additions when needed. This supports reuse of central business logic without forcing every analyst to rebuild the model from scratch.', 'Kompositmodelle können kontrollierte semantische Modelle bei Bedarf mit lokalen Ergänzungen erweitern. Das unterstützt die Wiederverwendung zentraler Geschäftslogik, ohne dass jeder Analyst das Modell von Grund auf neu erstellen muss.'),
      t('Reuse central logic, extend only where necessary.', 'Nutzen Sie zentrale Logik wieder und erweitern Sie nur dort, wo es nötig ist.'),
      ref.directLake),

    q('dp700-179', 'single', semantic, 'medium', null,
      t('What is a common use of ALL in DAX?', 'Wofür wird ALL in DAX häufig verwendet?'),
      [
        o('A', 'Remove filters from a table or column inside a calculation', 'Filter von einer Tabelle oder Spalte innerhalb einer Berechnung entfernen'),
        o('B', 'Create a workspace domain', 'Eine Arbeitsbereichsdomäne erstellen'),
        o('C', 'Schedule a pipeline', 'Eine Pipeline planen'),
        o('D', 'Create a paginated report parameter', 'Einen Parameter für einen paginierten Bericht erstellen')
      ],
      ['A'],
      t('ALL is commonly used when a measure needs to ignore some filters, such as when calculating ratios against a grand total. It changes the filter context used by the expression.', 'ALL wird häufig verwendet, wenn eine Measure einige Filter ignorieren muss, etwa bei der Berechnung von Anteilen am Gesamtergebnis. Es verändert den für den Ausdruck verwendeten Filterkontext.'),
      t('Think grand totals and ignoring filters.', 'Denken Sie an Gesamtsummen und das Ignorieren von Filtern.'),
      ref.daxAll),

    q('dp700-180', 'single', semantic, 'medium', null,
      t('Why is a proper Date table important for many DAX time-intelligence calculations?', 'Warum ist eine korrekte Datumstabelle für viele DAX-Time-Intelligence-Berechnungen wichtig?'),
      [
        o('A', 'Time-intelligence functions depend on a consistent date column and calendar context', 'Time-Intelligence-Funktionen hängen von einer konsistenten Datumsspalte und Kalenderlogik ab'),
        o('B', 'It increases workspace roles automatically', 'Sie erhöht automatisch die Anzahl von Arbeitsbereichsrollen'),
        o('C', 'It replaces all fact tables', 'Sie ersetzt alle Faktentabellen'),
        o('D', 'It disables Direct Lake', 'Sie deaktiviert Direct Lake')
      ],
      ['A'],
      t('Time-intelligence functions rely on a well-defined date dimension so they can correctly identify periods such as year-to-date or prior year. Poor date modeling leads to incorrect calculations.', 'Time-Intelligence-Funktionen benötigen eine sauber definierte Datumsdimension, damit sie Zeiträume wie Jahr-bis-heute oder Vorjahr korrekt identifizieren können. Schlechte Datumsmodellierung führt zu falschen Berechnungen.'),
      t('The date table provides the calendar logic.', 'Die Datumstabelle liefert die Kalenderlogik.'),
      ref.relationships),

    q('dp700-181', 'single', semantic, 'medium', null,
      t('When a model has both an active and an inactive relationship between the same two tables, which one is used by default?', 'Wenn ein Modell sowohl eine aktive als auch eine inaktive Beziehung zwischen denselben zwei Tabellen hat, welche wird standardmäßig verwendet?'),
      [
        o('A', 'The active relationship', 'Die aktive Beziehung'),
        o('B', 'The inactive relationship', 'Die inaktive Beziehung'),
        o('C', 'Neither relationship can be used', 'Keine der Beziehungen kann verwendet werden'),
        o('D', 'The relationship with the longest table name', 'Die Beziehung mit dem längsten Tabellennamen')
      ],
      ['A'],
      t('Power BI uses the active relationship automatically for filter propagation. Inactive relationships require explicit activation in a calculation, commonly with USERELATIONSHIP.', 'Power BI verwendet automatisch die aktive Beziehung für die Filterweitergabe. Inaktive Beziehungen müssen in einer Berechnung explizit aktiviert werden, üblicherweise mit USERELATIONSHIP.'),
      t('Default behavior follows the active relationship.', 'Das Standardverhalten folgt der aktiven Beziehung.'),
      ref.relationships),

    q('dp700-182', 'single', semantic, 'hard',
      t('HR viewers may see only employees in their country, while salary columns must be hidden from most of those viewers even for rows they are allowed to access.', 'HR-Betrachter dürfen nur Mitarbeiter ihres Landes sehen, während Gehaltsspalten für die meisten dieser Betrachter verborgen sein müssen, selbst für Zeilen, auf die sie zugreifen dürfen.'),
      t('What combination best addresses the requirement?', 'Welche Kombination erfüllt die Anforderung am besten?'),
      [
        o('A', 'Use RLS for country filtering and OLS for salary column visibility', 'Verwenden Sie RLS für die Länderfilterung und OLS für die Sichtbarkeit der Gehaltsspalten'),
        o('B', 'Use bookmarks only', 'Verwenden Sie nur Lesezeichen'),
        o('C', 'Use Q&A synonyms only', 'Verwenden Sie nur Q&A-Synonyme'),
        o('D', 'Use incremental refresh only', 'Verwenden Sie nur inkrementelle Aktualisierung')
      ],
      ['A'],
      t('RLS and OLS solve different security needs. RLS filters which rows a user can see, while OLS hides specific tables or columns such as sensitive salary information.', 'RLS und OLS lösen unterschiedliche Sicherheitsanforderungen. RLS filtert, welche Zeilen ein Benutzer sehen kann, während OLS bestimmte Tabellen oder Spalten wie sensible Gehaltsinformationen verbirgt.'),
      t('One requirement is row filtering, the other is object hiding.', 'Eine Anforderung ist Zeilenfilterung, die andere das Verbergen von Objekten.'),
      ref.ols),

    q('dp700-183', 'single', semantic, 'hard',
      t('A report query groups sales by Month and Product Category. An aggregation table exists at Month and Product Category grain over a much larger DirectQuery fact table.', 'Eine Berichtsabfrage gruppiert Verkäufe nach Monat und Produktkategorie. Es existiert eine Aggregationstabelle auf der Granularität Monat und Produktkategorie über einer viel größeren DirectQuery-Faktentabelle.'),
      t('What is the likely performance outcome if the aggregations are mapped correctly?', 'Was ist das wahrscheinliche Leistungsergebnis, wenn die Aggregationen korrekt zugeordnet sind?'),
      [
        o('A', 'The query can be answered from the aggregation instead of hitting the detail fact table', 'Die Abfrage kann aus der Aggregation beantwortet werden, statt die Detail-Faktentabelle zu treffen'),
        o('B', 'The query will always ignore the aggregation and scan the detail table', 'Die Abfrage ignoriert die Aggregation immer und scannt die Detailtabelle'),
        o('C', 'The aggregation removes the need for any relationships', 'Die Aggregation macht Beziehungen überflüssig'),
        o('D', 'The model can no longer support detail drillthrough', 'Das Modell kann keinen Detail-Drillthrough mehr unterstützen')
      ],
      ['A'],
      t('When a query matches the aggregation grain and mappings, Power BI can answer it from the aggregated data, which is much faster than going to the lower-grain DirectQuery table.', 'Wenn eine Abfrage zur Aggregationsgranularität und den Zuordnungen passt, kann Power BI sie aus den aggregierten Daten beantworten, was viel schneller ist als der Zugriff auf die DirectQuery-Tabelle mit niedrigerer Granularität.'),
      t('Match the query grain to the aggregation grain.', 'Passen Sie die Abfragegranularität an die Aggregationsgranularität an.'),
      ref.aggregations),

    q('dp700-184', 'single', semantic, 'medium', null,
      t('What is a key benefit of deployment pipelines when promoting semantic models across environments?', 'Was ist ein wesentlicher Vorteil von Deployment-Pipelines beim Überführen semantischer Modelle über Umgebungen hinweg?'),
      [
        o('A', 'They provide a structured dev, test, and prod promotion workflow', 'Sie bieten einen strukturierten Workflow für Entwicklung, Test und Produktion'),
        o('B', 'They replace DAX measures automatically', 'Sie ersetzen DAX-Measures automatisch'),
        o('C', 'They make RLS unnecessary', 'Sie machen RLS überflüssig'),
        o('D', 'They convert DirectQuery to Import at runtime', 'Sie konvertieren DirectQuery zur Laufzeit in Import')
      ],
      ['A'],
      t('Deployment pipelines help teams manage content lifecycle across stages in a controlled way. That is especially valuable for semantic models that need testing before production release.', 'Deployment-Pipelines helfen Teams, den Lebenszyklus von Inhalten kontrolliert über Stufen hinweg zu verwalten. Das ist besonders wertvoll für semantische Modelle, die vor der Produktivsetzung getestet werden müssen.'),
      t('Think lifecycle management across environments.', 'Denken Sie an Lebenszyklusmanagement über Umgebungen hinweg.'),
      ref.deployment),

    q('dp700-185', 'multiple', semantic, 'hard',
      t('A 2 TB historical model must remain queryable, but daily refresh windows are tight and only recent data changes. The model is hosted on Fabric capacity.', 'Ein historisches Modell mit 2 TB muss weiterhin abfragbar bleiben, aber die täglichen Aktualisierungsfenster sind eng und nur aktuelle Daten ändern sich. Das Modell wird auf Fabric-Kapazität gehostet.'),
      t('Which two actions are most relevant?', 'Welche zwei Maßnahmen sind am relevantesten?'),
      [
        o('A', 'Enable large semantic model storage format', 'Aktivieren Sie das Speicherformat für große semantische Modelle'),
        o('B', 'Configure incremental refresh', 'Konfigurieren Sie inkrementelle Aktualisierung'),
        o('C', 'Replace the model with bookmarks', 'Ersetzen Sie das Modell durch Lesezeichen'),
        o('D', 'Disable relationships to reduce model size', 'Deaktivieren Sie Beziehungen, um die Modellgröße zu reduzieren')
      ],
      ['A', 'B'],
      t('Large semantic model storage format addresses the model size requirement, while incremental refresh limits refresh work to the changing data range. Together they support scale and manageable refresh duration.', 'Das Speicherformat für große semantische Modelle adressiert die Anforderung an die Modellgröße, während die inkrementelle Aktualisierung die Aktualisierungsarbeit auf den sich ändernden Datenbereich begrenzt. Zusammen unterstützen sie Skalierung und beherrschbare Aktualisierungsdauer.'),
      t('One action supports scale, the other supports refresh efficiency.', 'Eine Maßnahme unterstützt die Skalierung, die andere die Effizienz der Aktualisierung.'),
      ref.largeModels),

    q('dp700-186', 'single', explore, 'easy', null,
      t('What is a practical advantage of using notebook visualizations during exploratory analysis?', 'Was ist ein praktischer Vorteil der Verwendung von Notebook-Visualisierungen bei der explorativen Analyse?'),
      [
        o('A', 'You can inspect trends and distributions quickly without leaving the notebook', 'Sie können Trends und Verteilungen schnell untersuchen, ohne das Notebook zu verlassen'),
        o('B', 'You can manage tenant settings', 'Sie können Mandanteneinstellungen verwalten'),
        o('C', 'You can replace all warehouse tables', 'Sie können alle Warehouse-Tabellen ersetzen'),
        o('D', 'You can create workspace roles automatically', 'Sie können Arbeitsbereichsrollen automatisch erstellen')
      ],
      ['A'],
      t('Built-in notebook visualizations shorten the feedback loop during exploration because results can be charted immediately beside the code. This is ideal for investigating patterns and anomalies.', 'Integrierte Notebook-Visualisierungen verkürzen die Rückkopplungsschleife bei der Exploration, weil Ergebnisse direkt neben dem Code visualisiert werden können. Das ist ideal, um Muster und Anomalien zu untersuchen.'),
      t('Fast visual feedback inside the notebook is the key.', 'Schnelle visuelle Rückmeldung innerhalb des Notebooks ist entscheidend.'),
      ref.notebook),

    q('dp700-187', 'single', explore, 'medium', null,
      t('Why would a SQL-focused analyst use the SQL analytics endpoint of a lakehouse during data exploration?', 'Warum würde ein SQL-orientierter Analyst den SQL-Analyseendpunkt eines Lakehouse während der Datenexploration verwenden?'),
      [
        o('A', 'It allows read-only T-SQL queries over lakehouse tables', 'Er ermöglicht schreibgeschützte T-SQL-Abfragen über Lakehouse-Tabellen'),
        o('B', 'It assigns workspace permissions', 'Er weist Arbeitsbereichsberechtigungen zu'),
        o('C', 'It replaces semantic models permanently', 'Er ersetzt semantische Modelle dauerhaft'),
        o('D', 'It is the only place to write Spark code', 'Er ist der einzige Ort, um Spark-Code zu schreiben')
      ],
      ['A'],
      t('The SQL analytics endpoint gives SQL users a familiar query surface over lakehouse tables without moving or duplicating the data. That makes ad hoc exploration easier for T-SQL users.', 'Der SQL-Analyseendpunkt bietet SQL-Benutzern eine vertraute Abfrageoberfläche über Lakehouse-Tabellen, ohne die Daten zu verschieben oder zu duplizieren. Das erleichtert T-SQL-Benutzern die Ad-hoc-Exploration.'),
      t('Choose the T-SQL exploration surface.', 'Wählen Sie die T-SQL-Oberfläche für Exploration.'),
      ref.queryWarehouse),

    q('dp700-188', 'multiple', explore, 'hard',
      t('You need to analyze telemetry from the last 15 minutes and chart error counts in 5-minute buckets by service.', 'Sie müssen Telemetrie aus den letzten 15 Minuten analysieren und Fehleranzahlen in 5-Minuten-Buckets nach Dienst grafisch darstellen.'),
      t('Which two KQL concepts are most useful?', 'Welche zwei KQL-Konzepte sind am nützlichsten?'),
      [
        o('A', 'A where clause filtering the recent time window', 'Eine where-Klausel zum Filtern des aktuellen Zeitfensters'),
        o('B', 'summarize with bin(Timestamp, 5m)', 'summarize mit bin(Timestamp, 5m)'),
        o('C', 'Workspace role inheritance', 'Vererbung von Arbeitsbereichsrollen'),
        o('D', 'Bookmark groups', 'Lesezeichengruppen')
      ],
      ['A', 'B'],
      t('A time filter narrows the dataset to the last 15 minutes, and summarize with bin groups events into consistent 5-minute buckets for aggregation and charting.', 'Ein Zeitfilter grenzt den Datensatz auf die letzten 15 Minuten ein, und summarize mit bin gruppiert Ereignisse in konsistente 5-Minuten-Buckets für Aggregation und Diagramme.'),
      t('One concept filters the window, the other groups it.', 'Ein Konzept filtert das Zeitfenster, das andere gruppiert es.'),
      ref.kql),

    q('dp700-189', 'single', explore, 'medium',
      t('An executive dashboard shows total revenue by region. Users want to right-click a region and jump to a page with only that region and its customer details.', 'Ein Executive-Dashboard zeigt den Gesamtumsatz nach Region. Benutzer möchten mit Rechtsklick auf eine Region zu einer Seite springen, die nur diese Region und ihre Kundendetails zeigt.'),
      t('Which Power BI feature should you use?', 'Welche Power-BI-Funktion sollten Sie verwenden?'),
      [
        o('A', 'Drillthrough', 'Drillthrough'),
        o('B', 'Tenant settings', 'Mandanteneinstellungen'),
        o('C', 'VACUUM', 'VACUUM'),
        o('D', 'Shortcut', 'Shortcut')
      ],
      ['A'],
      t('Drillthrough is designed for navigation from a summary visual to a detail page filtered to the selected context. It is ideal for this region-to-details workflow.', 'Drillthrough ist für die Navigation von einem Übersichtsvisual zu einer Detailseite gedacht, die auf den ausgewählten Kontext gefiltert ist. Er ist ideal für diesen Workflow von Region zu Details.'),
      t('Think summary page to filtered detail page.', 'Denken Sie an eine Übersichtsseite zu einer gefilterten Detailseite.'),
      ref.drillthrough),

    q('dp700-190', 'single', explore, 'medium', null,
      t('What are report bookmarks commonly used for in Power BI?', 'Wofür werden Berichtslesezeichen in Power BI häufig verwendet?'),
      [
        o('A', 'Capture a report page state such as filters, visibility, and sort order', 'Einen Berichtsseitenzustand wie Filter, Sichtbarkeit und Sortierung festzuhalten'),
        o('B', 'Create Delta tables', 'Delta-Tabellen zu erstellen'),
        o('C', 'Assign workspace roles', 'Arbeitsbereichsrollen zuzuweisen'),
        o('D', 'Mirror operational databases', 'Operative Datenbanken zu spiegeln')
      ],
      ['A'],
      t('Bookmarks store the current report state and are often used for guided storytelling, toggles, or tailored navigation experiences. They do not secure data or move it.', 'Lesezeichen speichern den aktuellen Berichtsstatus und werden häufig für geführtes Storytelling, Umschalter oder gezielte Navigationserlebnisse verwendet. Sie sichern oder verschieben keine Daten.'),
      t('Think saved report state.', 'Denken Sie an einen gespeicherten Berichtsstatus.'),
      ref.bookmarks),

    q('dp700-191', 'multiple', explore, 'medium', null,
      t('Which two design actions can improve the natural-language experience for Power BI Q&A?', 'Welche zwei Designmaßnahmen können die Natural-Language-Erfahrung für Power BI Q&A verbessern?'),
      [
        o('A', 'Use friendly table and field names', 'Verwenden Sie benutzerfreundliche Tabellen- und Feldnamen'),
        o('B', 'Define synonyms for important business terms', 'Definieren Sie Synonyme für wichtige Geschäftsbegriffe'),
        o('C', 'Remove all relationships from the model', 'Entfernen Sie alle Beziehungen aus dem Modell'),
        o('D', 'Hide every measure from users', 'Blenden Sie jede Measure für Benutzer aus')
      ],
      ['A', 'B'],
      t('Q&A works better when the model uses clear business terminology and synonyms that match how users ask questions. Removing relationships or hiding key fields makes the experience worse.', 'Q&A funktioniert besser, wenn das Modell klare Geschäftsterminologie und Synonyme verwendet, die zu den Fragen der Benutzer passen. Beziehungen zu entfernen oder wichtige Felder auszublenden, verschlechtert die Erfahrung.'),
      t('Think about how users naturally phrase business questions.', 'Denken Sie daran, wie Benutzer geschäftliche Fragen natürlich formulieren.'),
      ref.qa),

    q('dp700-192', 'single', explore, 'medium',
      t('A finance department must generate a printable invoice document where users provide an invoice number and the report returns a fixed-layout output.', 'Eine Finanzabteilung muss ein druckbares Rechnungsdokument erzeugen, bei dem Benutzer eine Rechnungsnummer eingeben und der Bericht ein festes Layout liefert.'),
      t('Which reporting approach is best?', 'Welcher Berichtsansatz ist am besten geeignet?'),
      [
        o('A', 'Paginated report with a parameter', 'Paginierter Bericht mit einem Parameter'),
        o('B', 'Bookmark-only Power BI report', 'Nur mit Lesezeichen arbeitender Power-BI-Bericht'),
        o('C', 'Dataflow Gen2', 'Dataflow Gen2'),
        o('D', 'Workspace settings page', 'Seite mit Arbeitsbereichseinstellungen')
      ],
      ['A'],
      t('Paginated reports are optimized for fixed-layout, printable, document-style outputs and support parameters such as invoice number. This fits operational document generation well.', 'Paginierte Berichte sind für feste Layouts, druckbare, dokumentartige Ausgaben optimiert und unterstützen Parameter wie Rechnungsnummern. Das passt gut zur Erzeugung operativer Dokumente.'),
      t('Choose the document-oriented reporting experience.', 'Wählen Sie die dokumentorientierte Berichtserfahrung.'),
      ref.paginated),

    q('dp700-193', 'single', explore, 'medium', null,
      t('Which Fabric artifact is designed to visualize and monitor KQL query results for operational scenarios?', 'Welches Fabric-Artefakt ist dafür gedacht, KQL-Abfrageergebnisse für operative Szenarien zu visualisieren und zu überwachen?'),
      [
        o('A', 'Real-Time dashboard', 'Echtzeit-Dashboard'),
        o('B', 'Workspace role', 'Arbeitsbereichsrolle'),
        o('C', 'Shortcut', 'Shortcut'),
        o('D', 'Calculation group', 'Berechnungsgruppe')
      ],
      ['A'],
      t('Real-Time dashboards are built around KQL-backed visuals and monitoring scenarios. They are a natural choice for live telemetry, operational KPIs, and alerting workflows.', 'Echtzeit-Dashboards sind um KQL-gestützte Visuals und Überwachungsszenarien herum aufgebaut. Sie sind eine natürliche Wahl für Live-Telemetrie, operative KPIs und Alerting-Workflows.'),
      t('Choose the real-time monitoring surface.', 'Wählen Sie die Oberfläche für Echtzeitüberwachung.'),
      ref.dashboard),

    q('dp700-194', 'single', explore, 'hard',
      t('A team wants an alert whenever refrigerated trucks report a temperature above the allowed threshold, and they want the alert sent automatically without writing custom code.', 'Ein Team möchte einen Alarm erhalten, sobald Kühlfahrzeuge eine Temperatur über dem zulässigen Schwellenwert melden, und der Alarm soll ohne benutzerdefinierten Code automatisch gesendet werden.'),
      t('Which Fabric capability is the best fit?', 'Welche Fabric-Funktion ist am besten geeignet?'),
      [
        o('A', 'Fabric Activator', 'Fabric Activator'),
        o('B', 'Bookmark navigator', 'Lesezeichen-Navigator'),
        o('C', 'Large semantic model storage format', 'Speicherformat für große semantische Modelle'),
        o('D', 'Table clone', 'Tabellenklon')
      ],
      ['A'],
      t('Fabric Activator is a no-code event detection engine that can monitor incoming data and trigger actions such as notifications when conditions are met. That matches threshold-based alerting scenarios.', 'Fabric Activator ist eine No-Code-Engine zur Ereigniserkennung, die eingehende Daten überwachen und Aktionen wie Benachrichtigungen auslösen kann, wenn Bedingungen erfüllt sind. Das passt zu schwellenwertbasierten Alarmierungsszenarien.'),
      t('Think no-code monitoring plus action on a condition.', 'Denken Sie an No-Code-Überwachung plus Aktion bei einer Bedingung.'),
      ref.activator),

    q('dp700-195', 'single', explore, 'medium',
      t('A data scientist prepares a DataFrame in PySpark and then wants to run a quick SQL check against a managed table in the same notebook before sharing findings.', 'Ein Data Scientist bereitet einen DataFrame in PySpark vor und möchte dann im selben Notebook eine schnelle SQL-Prüfung gegen eine verwaltete Tabelle durchführen, bevor Ergebnisse geteilt werden.'),
      t('What is a practical benefit of Fabric notebooks here?', 'Was ist hier ein praktischer Vorteil von Fabric-Notebooks?'),
      [
        o('A', 'They allow mixed languages such as PySpark and SQL in one workflow', 'Sie erlauben gemischte Sprachen wie PySpark und SQL in einem Workflow'),
        o('B', 'They remove the need for compute completely', 'Sie beseitigen den Bedarf an Rechenleistung vollständig'),
        o('C', 'They replace all semantic models', 'Sie ersetzen alle semantischen Modelle'),
        o('D', 'They automatically assign row-level security', 'Sie weisen automatisch Row-Level-Security zu')
      ],
      ['A'],
      t('Fabric notebooks support multiple languages in the same analysis flow, which makes it easy to combine engineering logic with quick SQL validation and visual checks.', 'Fabric-Notebooks unterstützen mehrere Sprachen in derselben Analyse, wodurch sich Engineering-Logik leicht mit schneller SQL-Validierung und visuellen Prüfungen kombinieren lässt.'),
      t('Think one notebook, multiple languages.', 'Denken Sie an ein Notebook mit mehreren Sprachen.'),
      ref.notebook),

    q('dp700-196', 'single', explore, 'hard', null,
      t('You are exploring semi-structured JSON payloads in a KQL table and need to extract nested properties for analysis.', 'Sie untersuchen semistrukturierte JSON-Nutzlasten in einer KQL-Tabelle und müssen verschachtelte Eigenschaften für Analysen extrahieren.'),
      t('Which KQL capability is most relevant?', 'Welche KQL-Funktion ist am relevantesten?'),
      [
        o('A', 'JSON parsing and extraction functions such as parse_json', 'JSON-Parsing- und Extraktionsfunktionen wie parse_json'),
        o('B', 'Workspace domain mapping', 'Zuordnung von Arbeitsbereichsdomänen'),
        o('C', 'Paginated report parameters', 'Parameter für paginierte Berichte'),
        o('D', 'Object-level security roles', 'Object-Level-Security-Rollen')
      ],
      ['A'],
      t('KQL includes parsing functions that make it well suited to semi-structured telemetry and log exploration. These functions let you extract fields for filtering and aggregation.', 'KQL enthält Parsing-Funktionen, die sich gut für die Exploration semistrukturierter Telemetrie- und Logdaten eignen. Mit ihnen können Felder für Filterung und Aggregation extrahiert werden.'),
      t('Choose the option related to parsing semi-structured values.', 'Wählen Sie die Option, die mit dem Parsen semistrukturierter Werte zusammenhängt.'),
      ref.kql),

    q('dp700-197', 'single', explore, 'medium',
      t('An operations center needs a live dashboard that refreshes frequently from KQL queries over streaming telemetry.', 'Ein Leitstand benötigt ein Live-Dashboard, das häufig aus KQL-Abfragen über Streaming-Telemetrie aktualisiert wird.'),
      t('Which Fabric experience best fits?', 'Welche Fabric-Erfahrung passt am besten?'),
      [
        o('A', 'Real-Time dashboard', 'Echtzeit-Dashboard'),
        o('B', 'Paginated report', 'Paginierter Bericht'),
        o('C', 'Workspace settings', 'Arbeitsbereichseinstellungen'),
        o('D', 'Bookmark pane', 'Lesezeichenbereich')
      ],
      ['A'],
      t('Real-Time dashboards are built for monitoring scenarios with live or frequently refreshed KQL-backed visuals. They are a better fit than fixed-layout documents for operational telemetry.', 'Echtzeit-Dashboards sind für Überwachungsszenarien mit Live- oder häufig aktualisierten KQL-gestützten Visuals gedacht. Sie passen besser als feste Dokumentlayouts für operative Telemetrie.'),
      t('Choose the live operational dashboard experience.', 'Wählen Sie die Live-Erfahrung für operative Dashboards.'),
      ref.dashboard),

    q('dp700-198', 'single', explore, 'medium', null,
      t('What is an important security characteristic of the SQL analytics endpoint on a lakehouse?', 'Was ist eine wichtige Sicherheitseigenschaft des SQL-Analyseendpunkts eines Lakehouse?'),
      [
        o('A', 'It provides read-only SQL access and still depends on the broader Fabric security model', 'Er bietet schreibgeschützten SQL-Zugriff und hängt weiterhin vom breiteren Fabric-Sicherheitsmodell ab'),
        o('B', 'It ignores workspace and item permissions', 'Er ignoriert Arbeitsbereichs- und Elementberechtigungen'),
        o('C', 'It is publicly accessible by default on the internet', 'Er ist standardmäßig öffentlich im Internet zugänglich'),
        o('D', 'It replaces RLS inside semantic models', 'Er ersetzt RLS in semantischen Modellen')
      ],
      ['A'],
      t('The SQL analytics endpoint is a read-only query surface, but it does not bypass Fabric security. Access remains governed by the platform security model and permissions.', 'Der SQL-Analyseendpunkt ist eine schreibgeschützte Abfrageoberfläche, umgeht aber die Fabric-Sicherheit nicht. Der Zugriff bleibt durch das Sicherheitsmodell und die Berechtigungen der Plattform gesteuert.'),
      t('Read-only does not mean security-free.', 'Schreibgeschützt bedeutet nicht sicherheitsfrei.'),
      ref.queryWarehouse),

    q('dp700-199', 'multiple', explore, 'medium',
      t('A sales report should let users expand from Year to Quarter to Month on a chart, and hovering a product should show a mini summary without leaving the page.', 'Ein Verkaufsbericht soll Benutzern erlauben, in einem Diagramm von Jahr zu Quartal zu Monat aufzuklappen, und beim Überfahren eines Produkts mit der Maus soll eine kleine Zusammenfassung angezeigt werden, ohne die Seite zu verlassen.'),
      t('Which two Power BI features are relevant?', 'Welche zwei Power-BI-Funktionen sind relevant?'),
      [
        o('A', 'Hierarchy drilldown', 'Hierarchie-Drilldown'),
        o('B', 'Report tooltips', 'Berichtstooltips'),
        o('C', 'Tenant settings', 'Mandanteneinstellungen'),
        o('D', 'VACUUM', 'VACUUM')
      ],
      ['A', 'B'],
      t('Hierarchy drilldown supports moving through levels such as Year, Quarter, and Month. Report tooltips add contextual detail on hover without requiring page navigation.', 'Hierarchie-Drilldown unterstützt das Wechseln durch Ebenen wie Jahr, Quartal und Monat. Berichtstooltips liefern kontextbezogene Details beim Darüberfahren, ohne Seitenwechsel zu erfordern.'),
      t('One feature expands hierarchy levels, the other adds hover detail.', 'Eine Funktion erweitert Hierarchieebenen, die andere liefert Details beim Überfahren.'),
      ref.drillthrough),

    q('dp700-200', 'single', explore, 'medium',
      t('A compliance team needs printable monthly statements that can also be exported to PDF or Excel in a controlled layout.', 'Ein Compliance-Team benötigt druckbare Monatsauszüge, die auch in einem kontrollierten Layout nach PDF oder Excel exportiert werden können.'),
      t('Which reporting option is best?', 'Welche Berichtsoption ist am besten?'),
      [
        o('A', 'Paginated report', 'Paginierter Bericht'),
        o('B', 'KQL dashboard', 'KQL-Dashboard'),
        o('C', 'Bookmark set', 'Lesezeichensatz'),
        o('D', 'Notebook markdown output', 'Notebook-Markdown-Ausgabe')
      ],
      ['A'],
      t('Paginated reports are purpose-built for controlled fixed-layout output and common export scenarios such as PDF and Excel. They are ideal for statement-style reporting.', 'Paginierte Berichte sind speziell für kontrollierte Ausgaben mit festem Layout und gängige Exportszenarien wie PDF und Excel gedacht. Sie sind ideal für berichtsartige Auszüge.'),
      t('Think document-quality export and printing.', 'Denken Sie an druck- und dokumenttauglichen Export.'),
      ref.paginated),

    q('dp700-201', 'single', explore, 'hard',
      t('A business user wants an automatic Teams notification whenever website conversion rate drops below a threshold shown in near real time on Fabric data.', 'Ein Fachanwender möchte eine automatische Teams-Benachrichtigung, sobald die Website-Conversion-Rate unter einen Schwellenwert fällt, der nahezu in Echtzeit auf Fabric-Daten angezeigt wird.'),
      t('Which capability best supports this?', 'Welche Funktion unterstützt dies am besten?'),
      [
        o('A', 'Fabric Activator', 'Fabric Activator'),
        o('B', 'Table clone', 'Tabellenklon'),
        o('C', 'Calculation group', 'Berechnungsgruppe'),
        o('D', 'Domain delegation', 'Domänendelegation')
      ],
      ['A'],
      t('Fabric Activator continuously monitors data conditions and can trigger actions such as Teams or email notifications when rules are met. This is the no-code event-to-action pattern.', 'Fabric Activator überwacht Datenbedingungen kontinuierlich und kann Aktionen wie Teams- oder E-Mail-Benachrichtigungen auslösen, wenn Regeln erfüllt sind. Das ist das No-Code-Muster Ereignis-zu-Aktion.'),
      t('Choose the engine that monitors data and triggers actions.', 'Wählen Sie die Engine, die Daten überwacht und Aktionen auslöst.'),
      ref.activator),

    q('dp700-202', 'single', explore, 'medium', null,
      t('What is a KQL queryset primarily used for?', 'Wofür wird ein KQL-Queryset hauptsächlich verwendet?'),
      [
        o('A', 'Writing, saving, and organizing KQL queries and results', 'Zum Schreiben, Speichern und Organisieren von KQL-Abfragen und Ergebnissen'),
        o('B', 'Managing workspace roles', 'Zum Verwalten von Arbeitsbereichsrollen'),
        o('C', 'Creating Delta transaction logs', 'Zum Erstellen von Delta-Transaktionsprotokollen'),
        o('D', 'Scheduling semantic model refreshes', 'Zum Planen von Aktualisierungen semantischer Modelle')
      ],
      ['A'],
      t('A KQL queryset is the authoring surface for working with KQL in Fabric. It lets users create, save, rerun, and share analytical queries and their results.', 'Ein KQL-Queryset ist die Erstellungsoberfläche für die Arbeit mit KQL in Fabric. Es ermöglicht Benutzern, analytische Abfragen und deren Ergebnisse zu erstellen, zu speichern, erneut auszuführen und zu teilen.'),
      t('Think KQL authoring and reuse.', 'Denken Sie an KQL-Erstellung und Wiederverwendung.'),
      ref.queryset),

    q('dp700-203', '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 doing 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 built-in notebook visualization such as a histogram or box-style chart', 'Verwenden Sie eine integrierte Notebook-Visualisierung wie Histogramm oder boxähnliches Diagramm'),
        o('B', 'Assign new workspace roles', 'Weisen Sie neue Arbeitsbereichsrollen zu'),
        o('C', 'Create a paginated report immediately', 'Erstellen Sie sofort einen paginierten Bericht'),
        o('D', 'Turn the notebook into a deployment pipeline', 'Wandeln Sie das Notebook in eine Deployment-Pipeline um')
      ],
      ['A'],
      t('Notebook visualizations offer fast exploratory feedback and help reveal outliers and distributions without leaving the analytical workflow. That is an effective first diagnostic step.', 'Notebook-Visualisierungen liefern schnelle explorative Rückmeldung und helfen, Ausreißer und Verteilungen zu erkennen, ohne den Analyseworkflow zu verlassen. Das ist ein effektiver erster Diagnoseschritt.'),
      t('Visualize first, then decide on deeper analysis.', 'Visualisieren Sie zuerst und entscheiden Sie dann über die tiefere Analyse.'),
      ref.notebook),

    q('dp700-204', '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 den 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 the interactive exploration experience in Power BI. Selecting data in one visual highlights corresponding data in related visuals on the page.', 'Kreuzhervorhebung ist Teil der interaktiven Exploration in Power BI. Wenn Daten in einem Visual ausgewählt werden, werden entsprechende Daten in verwandten Visuals auf derselben Seite hervorgehoben.'),
      t('Think interaction between visuals on the same page.', 'Denken Sie an Interaktion zwischen Visuals auf derselben Seite.'),
      ref.drillthrough),

    q('dp700-205', 'single', explore, 'hard',
      t('You need to display request volume over time from a KQL query and show the trend as a line chart for operations monitoring.', 'Sie müssen das Anforderungsvolumen im Zeitverlauf aus einer KQL-Abfrage anzeigen und den Trend als Liniendiagramm für die Betriebsüberwachung darstellen.'),
      t('Which KQL visualization approach is most relevant?', 'Welcher KQL-Visualisierungsansatz ist am relevantesten?'),
      [
        o('A', 'Aggregate by time and render a timechart', 'Nach Zeit aggregieren und ein timechart rendern'),
        o('B', 'Use object-level security', 'Verwenden Sie Object-Level-Security'),
        o('C', 'Create a bookmark group', 'Erstellen Sie eine Lesezeichengruppe'),
        o('D', 'Enable large semantic model storage', 'Aktivieren Sie das Speicherformat für große semantische Modelle')
      ],
      ['A'],
      t('For time-series monitoring in KQL, a common pattern is to aggregate over time buckets and render the result as a timechart. This gives operations teams an immediate trend view.', 'Für Zeitreihenüberwachung in KQL ist es ein häufiges Muster, über Zeit-Buckets zu aggregieren und das Ergebnis als timechart zu rendern. Das gibt Betriebsteams sofort einen Trendüberblick.'),
      t('Think time buckets plus a time-series visualization.', 'Denken Sie an Zeit-Buckets plus eine Zeitreihenvisualisierung.'),
      ref.kql)
  ];

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