(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',
    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',
    warehouse: 'https://learn.microsoft.com/en-us/fabric/data-warehouse/data-warehousing',
    queryWarehouse: 'https://learn.microsoft.com/en-us/fabric/data-warehouse/query-warehouse',
    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',
    star: 'https://learn.microsoft.com/en-us/power-bi/guidance/star-schema',
    modelModes: 'https://learn.microsoft.com/en-us/power-bi/connect-data/service-dataset-modes-understand',
    directQuery: 'https://learn.microsoft.com/en-us/power-bi/connect-data/desktop-directquery-about',
    composite: 'https://learn.microsoft.com/en-us/power-bi/transform-model/desktop-composite-models',
    directLake: 'https://learn.microsoft.com/en-us/fabric/get-started/direct-lake-overview',
    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',
    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',
    daxAll: 'https://learn.microsoft.com/en-us/dax/all-function-dax',
    daxVar: 'https://learn.microsoft.com/en-us/dax/var-dax',
    daxUserRelationship: 'https://learn.microsoft.com/en-us/dax/userelationship-function-dax',
    daxTime: 'https://learn.microsoft.com/en-us/dax/totalytd-function-dax',
    drillthrough: 'https://learn.microsoft.com/en-us/power-bi/create-reports/desktop-drillthrough',
    paginated: 'https://learn.microsoft.com/en-us/power-bi/paginated-reports/paginated-reports-report-builder-power-bi',
    qa: 'https://learn.microsoft.com/en-us/power-bi/natural-language/q-and-a-tooling-intro',
    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-306', 'single', plan, 'medium',
      t('A self-service BI team must create reports, edit semantic models, and update the workspace app. They must not manage permissions or delete the workspace.', 'Ein Self-Service-BI-Team muss Berichte erstellen, semantische Modelle bearbeiten und die Arbeitsbereichs-App aktualisieren. Es darf jedoch keine Berechtigungen verwalten oder den Arbeitsbereich löschen.'),
      t('Which workspace role should you assign?', 'Welche Arbeitsbereichsrolle sollten Sie zuweisen?'),
      [
        o('A', 'Viewer', 'Betrachter'),
        o('B', 'Contributor', 'Mitwirkender'),
        o('C', 'Member', 'Mitglied'),
        o('D', 'Admin', 'Administrator')
      ],
      ['C'],
      t('Member supports content authoring and app management without granting full workspace administration. Viewer is read-only, Contributor cannot perform all member tasks, and Admin is too permissive.', 'Mitglied unterstützt Inhaltserstellung und App-Verwaltung, ohne volle Arbeitsbereichsadministration zu gewähren. Betrachter ist schreibgeschützt, Mitwirkender kann nicht alle Aufgaben eines Mitglieds ausführen, und Administrator ist zu weitreichend.'),
      t('Choose the authoring role that is stronger than Contributor but weaker than Admin.', 'Wählen Sie die Autorrolle, die stärker als Mitwirkender, aber schwächer als Administrator ist.'),
      ref.workspaces),

    q('dp700-307', 'single', plan, 'medium',
      t('Report users complain about random slowdowns on a Fabric capacity. You need evidence about time windows and workload types before changing the SKU.', 'Berichtsnutzer beschweren sich über zufällige Verlangsamungen auf einer Fabric-Kapazität. Sie benötigen Belege zu Zeitfenstern und Workload-Typen, bevor Sie die SKU ändern.'),
      t('What should you do first?', 'Was sollten Sie zuerst tun?'),
      [
        o('A', 'Review capacity metrics and workload placement', 'Überprüfen Sie Kapazitätsmetriken und die Platzierung der Workloads'),
        o('B', 'Move every workspace to shared capacity', 'Verschieben Sie jeden Arbeitsbereich auf gemeinsame Kapazität'),
        o('C', 'Disable semantic models', 'Deaktivieren Sie semantische Modelle'),
        o('D', 'Delete old notebooks', 'Löschen Sie alte Notebooks')
      ],
      ['A'],
      t('Capacity metrics are the starting point for evidence-based tuning. They show when pressure occurs and which workloads contribute, so you can decide whether isolation, scheduling, or scaling is the right answer.', 'Kapazitätsmetriken sind der Ausgangspunkt für eine belegbasierte Optimierung. Sie zeigen, wann Druck entsteht und welche Workloads dazu beitragen, sodass Sie entscheiden können, ob Isolation, Zeitplanung oder Skalierung die richtige Antwort ist.'),
      t('Measure first, resize second.', 'Erst messen, dann skalieren.'),
      ref.capacity),

    q('dp700-308', 'single', plan, 'easy', null,
      t('Why do organizations assign important Fabric workspaces to dedicated capacity instead of relying only on shared capacity?', 'Warum weisen Organisationen wichtige Fabric-Arbeitsbereiche einer dedizierten Kapazität zu, statt sich nur auf gemeinsame Kapazität zu verlassen?'),
      [
        o('A', 'To remove the need for workspace roles', 'Um die Notwendigkeit von Arbeitsbereichsrollen zu entfernen'),
        o('B', 'To gain more predictable compute performance and workload isolation', 'Um besser planbare Compute-Leistung und Workload-Isolation zu erhalten'),
        o('C', 'To force all models into Import mode', 'Um alle Modelle in den Importmodus zu zwingen'),
        o('D', 'To move OneLake data outside Fabric', 'Um OneLake-Daten außerhalb von Fabric zu verschieben')
      ],
      ['B'],
      t('Dedicated capacity provides isolated compute resources, better concurrency planning, and more predictable performance. Security roles and storage architecture are separate concerns.', 'Eine dedizierte Kapazität bietet isolierte Compute-Ressourcen, bessere Planung von Parallelität und planbarere Leistung. Sicherheitsrollen und Speicherarchitektur sind getrennte Themen.'),
      t('Think dedicated compute, not different permissions.', 'Denken Sie an dedizierte Compute-Leistung und nicht an andere Berechtigungen.'),
      ref.capacity),

    q('dp700-309', 'single', plan, 'medium',
      t('A data team wants a curated relational analytics store that business analysts can query with T-SQL and model as a classic star schema. Spark-based data science is not a requirement.', 'Ein Datenteam möchte einen kuratierten relationalen Analysespeicher, den Fachanalysten mit T-SQL abfragen und als klassisches Sternschema modellieren können. Spark-basierte Data Science ist keine Anforderung.'),
      t('Which Fabric item is the best primary fit?', 'Welches Fabric-Element passt primär am besten?'),
      [
        o('A', 'Warehouse', 'Warehouse'),
        o('B', 'KQL Queryset', 'KQL-Queryset'),
        o('C', 'Dashboard', 'Dashboard'),
        o('D', 'Data Activator', 'Data Activator')
      ],
      ['A'],
      t('Fabric Warehouse is optimized for relational analytics with T-SQL over curated tables. That matches dimensional modeling and business reporting better than KQL, dashboards, or alerting tools.', 'Fabric Warehouse ist für relationale Analysen mit T-SQL über kuratierte Tabellen optimiert. Das passt besser zu dimensionaler Modellierung und Geschäftsberichten als KQL, Dashboards oder Alarmierungswerkzeuge.'),
      t('Choose the SQL-first relational store.', 'Wählen Sie den SQL-zentrierten relationalen Speicher.'),
      ref.warehouse),

    q('dp700-310', 'multiple', plan, 'medium', null,
      t('Which two actions align best with a data mesh approach in Microsoft Fabric?', 'Welche zwei Maßnahmen passen am besten zu einem Data-Mesh-Ansatz in Microsoft Fabric?'),
      [
        o('A', 'Organize workspaces and products by business domain', 'Organisieren Sie Arbeitsbereiche und Produkte nach Geschäftsdomänen'),
        o('B', 'Require one central platform team to publish every table', 'Verlangen Sie, dass ein zentrales Plattformteam jede Tabelle veröffentlicht'),
        o('C', 'Let domain teams own and publish their curated data products', 'Lassen Sie Domänenteams ihre kuratierten Datenprodukte selbst besitzen und veröffentlichen'),
        o('D', 'Store every domain asset in one shared workspace', 'Speichern Sie jedes Domänenartefakt in einem gemeinsamen Arbeitsbereich')
      ],
      ['A', 'C'],
      t('Data mesh emphasizes domain ownership and domain-aligned products. Fabric domains and separate workspaces support that pattern, while a single publishing team or one giant shared workspace works against it.', 'Data Mesh betont Domänenverantwortung und domänenorientierte Produkte. Fabric-Domänen und getrennte Arbeitsbereiche unterstützen dieses Muster, während ein einziges Veröffentlichungsteam oder ein riesiger gemeinsamer Arbeitsbereich dagegen arbeiten.'),
      t('Pick the answers that reinforce domain ownership.', 'Wählen Sie die Antworten, die Domänenverantwortung stärken.'),
      ref.domains),

    q('dp700-311', 'single', plan, 'medium',
      t('A legal team does not allow copying source files from ADLS Gen2 into Fabric storage, but analysts still need to work with the data from Fabric.', 'Ein Rechtsteam erlaubt nicht, Quelldateien aus ADLS Gen2 in den Fabric-Speicher zu kopieren, aber Analysten müssen trotzdem mit den Daten aus Fabric arbeiten.'),
      t('Which approach should you choose?', 'Welchen Ansatz sollten Sie wählen?'),
      [
        o('A', 'Create a OneLake shortcut', 'Erstellen Sie einen OneLake-Shortcut'),
        o('B', 'Mirror the files into a warehouse', 'Spiegeln Sie die Dateien in ein Warehouse'),
        o('C', 'Export the data to Excel', 'Exportieren Sie die Daten nach Excel'),
        o('D', 'Use a paginated report as the storage layer', 'Verwenden Sie einen paginierten Bericht als Speicherschicht')
      ],
      ['A'],
      t('OneLake shortcuts expose external data in Fabric without duplicating it in OneLake storage. That satisfies the no-copy requirement while preserving access.', 'OneLake-Shortcuts machen externe Daten in Fabric verfügbar, ohne sie im OneLake-Speicher zu duplizieren. Das erfüllt die No-Copy-Anforderung und erhält gleichzeitig den Zugriff.'),
      t('The key phrase is access without copying.', 'Der Schlüsselsatz lautet Zugriff ohne Kopieren.'),
      ref.shortcuts),

    q('dp700-312', 'single', plan, 'medium',
      t('You need low-latency replicated copies of Azure SQL operational data inside Fabric for downstream analytics workloads.', 'Sie benötigen replizierte Kopien mit geringer Latenz von operativen Azure-SQL-Daten in Fabric für nachgelagerte Analyse-Workloads.'),
      t('Which capability best fits?', 'Welche Funktion passt am besten?'),
      [
        o('A', 'OneLake shortcut', 'OneLake-Shortcut'),
        o('B', 'Mirroring', 'Mirroring'),
        o('C', 'Bookmark', 'Lesezeichen'),
        o('D', 'Deployment pipeline', 'Deployment-Pipeline')
      ],
      ['B'],
      t('Mirroring is designed for low-latency replication of supported operational sources into Fabric. Unlike shortcuts, it creates local replicated data for analytics.', 'Mirroring ist für die Replikation unterstützter operativer Quellen mit geringer Latenz nach Fabric ausgelegt. Anders als Shortcuts erzeugt es lokale replizierte Daten für Analysen.'),
      t('The requirement is replicated data, not just virtual access.', 'Die Anforderung lautet replizierte Daten und nicht nur virtueller Zugriff.'),
      ref.mirroring),

    q('dp700-313', 'single', plan, 'easy', null,
      t('Which Fabric admin-center feature lets tenant admins enable or restrict specific Fabric capabilities for selected groups?', 'Welche Funktion im Fabric Admin Center ermöglicht es Mandantenadministratoren, bestimmte Fabric-Funktionen für ausgewählte Gruppen zu aktivieren oder einzuschränken?'),
      [
        o('A', 'Tenant settings', 'Mandanteneinstellungen'),
        o('B', 'Sensitivity labels', 'Vertraulichkeitsbezeichnungen'),
        o('C', 'Dataflows Gen2', 'Dataflows Gen2'),
        o('D', 'KQL dashboards', 'KQL-Dashboards')
      ],
      ['A'],
      t('Tenant settings are the control plane for enabling and restricting Fabric capabilities across the organization. They can be scoped to specific security groups when needed.', 'Mandanteneinstellungen sind die Steuerungsebene zum Aktivieren und Einschränken von Fabric-Funktionen in der gesamten Organisation. Bei Bedarf können sie auf bestimmte Sicherheitsgruppen begrenzt werden.'),
      t('Look for the tenant-wide governance surface.', 'Suchen Sie nach der mandantenweiten Governance-Oberfläche.'),
      ref.admin),

    q('dp700-314', 'single', plan, 'medium',
      t('A team wants one storage layer for open Delta tables, Spark notebooks, and SQL-based analytics over the same curated data.', 'Ein Team möchte eine Speicherschicht für offene Delta-Tabellen, Spark-Notebooks und SQL-basierte Analysen über dieselben kuratierten Daten.'),
      t('Which Fabric item should be the primary storage choice?', 'Welches Fabric-Element sollte die primäre Speicherwahl sein?'),
      [
        o('A', 'Lakehouse', 'Lakehouse'),
        o('B', 'Dashboard', 'Dashboard'),
        o('C', 'Deployment pipeline', 'Deployment-Pipeline'),
        o('D', 'Paginated report', 'Paginierter Bericht')
      ],
      ['A'],
      t('A lakehouse stores open Delta tables in OneLake for Spark and also exposes a SQL analytics endpoint. That makes it the best fit for shared Spark and SQL access.', 'Ein Lakehouse speichert offene Delta-Tabellen in OneLake für Spark und stellt zusätzlich einen SQL-Analyseendpunkt bereit. Damit ist es die beste Wahl für gemeinsamen Spark- und SQL-Zugriff.'),
      t('Choose the Fabric item that bridges Spark and SQL.', 'Wählen Sie das Fabric-Element, das Spark und SQL verbindet.'),
      ref.lakehouse),

    q('dp700-315', 'single', plan, 'hard',
      t('ETL notebooks and interactive reports run on the same Fabric capacity. Reports become slow every evening during large notebook jobs.', 'ETL-Notebooks und interaktive Berichte laufen auf derselben Fabric-Kapazität. Berichte werden jeden Abend während großer Notebook-Jobs langsam.'),
      t('What should you do first?', 'Was sollten Sie zuerst tun?'),
      [
        o('A', 'Separate heavy engineering workloads through workspace and capacity planning', 'Trennen Sie rechenintensive Engineering-Workloads durch Arbeitsbereichs- und Kapazitätsplanung'),
        o('B', 'Convert every notebook to Excel', 'Konvertieren Sie jedes Notebook nach Excel'),
        o('C', 'Delete report relationships', 'Löschen Sie Berichtsbeziehungen'),
        o('D', 'Force every model to DirectQuery', 'Zwingen Sie jedes Modell zu DirectQuery')
      ],
      ['A'],
      t('The problem is compute contention, so the first action is workload isolation and scheduling. Changing report design or model mode does not address the shared-capacity bottleneck directly.', 'Das Problem ist Compute-Konkurrenz, daher ist die erste Maßnahme Workload-Isolation und Zeitplanung. Das Ändern des Berichtdesigns oder des Modellmodus adressiert den Engpass gemeinsamer Kapazität nicht direkt.'),
      t('Fix workload placement before redesigning content.', 'Beheben Sie zuerst die Platzierung der Workloads, bevor Sie Inhalte neu gestalten.'),
      ref.capacity),

    q('dp700-316', 'multiple', plan, 'medium', null,
      t('Which two statements correctly describe OneLake?', 'Welche zwei Aussagen beschreiben OneLake korrekt?'),
      [
        o('A', 'It provides a single logical data lake for Fabric workloads', 'Es stellt einen einzigen logischen Data Lake für Fabric-Workloads bereit'),
        o('B', 'It requires each workspace to create a separate external storage account', 'Es erfordert, dass jeder Arbeitsbereich ein separates externes Speicherkonto erstellt'),
        o('C', 'Shortcuts can expose external data through OneLake without making another copy', 'Shortcuts können externe Daten über OneLake verfügbar machen, ohne eine weitere Kopie zu erstellen'),
        o('D', 'It replaces all workspace role assignments', 'Es ersetzt alle Arbeitsbereichs-Rollenzuweisungen')
      ],
      ['A', 'C'],
      t('OneLake is the unified logical data lake in Fabric, and shortcuts are one of the key ways to expose existing data without duplicating it. Security roles still matter, and OneLake does not require separate external accounts per workspace.', 'OneLake ist der einheitliche logische Data Lake in Fabric, und Shortcuts sind eine der wichtigsten Möglichkeiten, vorhandene Daten ohne Duplizierung verfügbar zu machen. Sicherheitsrollen bleiben weiterhin wichtig, und OneLake erfordert keine separaten externen Konten pro Arbeitsbereich.'),
      t('Look for unification and reduced data copies.', 'Achten Sie auf Vereinheitlichung und reduzierte Datenkopien.'),
      ref.onelake),

    q('dp700-317', 'single', plan, 'medium',
      t('A platform team wants decentralized ownership, where each business unit publishes and governs its own certified analytics products.', 'Ein Plattformteam möchte eine dezentrale Verantwortung, bei der jede Geschäftseinheit ihre eigenen zertifizierten Analyseprodukte veröffentlicht und verwaltet.'),
      t('Which architecture style does this describe?', 'Welchen Architekturansatz beschreibt dies?'),
      [
        o('A', 'Data mesh', 'Data Mesh'),
        o('B', 'Monolithic warehouse only', 'Nur monolithisches Warehouse'),
        o('C', 'Desktop file sharing', 'Teilen von Desktop-Dateien'),
        o('D', 'Single-user sandboxing', 'Sandboxing für Einzelbenutzer')
      ],
      ['A'],
      t('Data mesh is based on domain ownership and product thinking. Fabric domains, workspaces, and endorsements help implement that style in a governed way.', 'Data Mesh basiert auf Domänenverantwortung und Produktdenken. Fabric-Domänen, Arbeitsbereiche und Endorsements helfen, diesen Ansatz auf kontrollierte Weise umzusetzen.'),
      t('Decentralized ownership is the clue.', 'Dezentrale Verantwortung ist der Hinweis.'),
      ref.domains),

    q('dp700-318', 'single', plan, 'easy', null,
      t('Which Fabric discovery experience helps users find trusted and endorsed data items across the organization?', 'Welche Fabric-Discovery-Erfahrung hilft Benutzern, vertrauenswürdige und bestätigte Datenelemente in der gesamten Organisation zu finden?'),
      [
        o('A', 'OneLake data hub', 'OneLake Data Hub'),
        o('B', 'Notebook cell output', 'Notebook-Zellenausgabe'),
        o('C', 'Spark session settings', 'Spark-Sitzungseinstellungen'),
        o('D', 'Deployment rules only', 'Nur Bereitstellungsregeln')
      ],
      ['A'],
      t('The OneLake data hub is designed for discovery of data items, including endorsed and trusted assets. It supports self-service users who need to find the right data product.', 'Der OneLake Data Hub ist für die Auffindung von Datenelementen einschließlich bestätigter und vertrauenswürdiger Artefakte ausgelegt. Er unterstützt Self-Service-Benutzer bei der Suche nach dem richtigen Datenprodukt.'),
      t('Think discovery and trust, not development settings.', 'Denken Sie an Auffindung und Vertrauen und nicht an Entwicklungseinstellungen.'),
      ref.catalog),

    q('dp700-319', 'single', plan, 'hard',
      t('Large overnight notebook jobs finish before 6 AM, but interactive report queries are still delayed at 8 AM on the same capacity.', 'Große nächtliche Notebook-Jobs sind vor 6 Uhr beendet, aber interaktive Berichtsabfragen sind um 8 Uhr auf derselben Kapazität immer noch verzögert.'),
      t('What is the best explanation?', 'Was ist die beste Erklärung?'),
      [
        o('A', 'Background usage can be smoothed over time, and sustained overages can still affect later capacity behavior', 'Hintergrundnutzung kann über die Zeit geglättet werden, und anhaltende Überlastungen können dennoch spätere Kapazitätsvorgänge beeinflussen'),
        o('B', 'Interactive queries always use a separate hidden capacity', 'Interaktive Abfragen verwenden immer eine separate versteckte Kapazität'),
        o('C', 'Notebook jobs consume capacity only while the Spark UI is open', 'Notebook-Jobs verbrauchen nur Kapazität, solange die Spark-Benutzeroberfläche geöffnet ist'),
        o('D', 'Smoothing means the jobs were free', 'Glättung bedeutet, dass die Jobs kostenlos waren')
      ],
      ['A'],
      t('Fabric can smooth certain background consumption over time, but the usage still counts against the capacity. When overages accumulate, later operations can see throttling or delay.', 'Fabric kann bestimmte Hintergrundverbräuche über die Zeit glätten, aber die Nutzung zählt weiterhin gegen die Kapazität. Wenn sich Überlastungen ansammeln, können spätere Vorgänge gedrosselt oder verzögert werden.'),
      t('Smoothed does not mean ignored.', 'Geglättet bedeutet nicht ignoriert.'),
      ref.smoothing),

    q('dp700-320', 'multiple', plan, 'medium', null,
      t('Which two actions improve governance and traceability for Fabric data products?', 'Welche zwei Maßnahmen verbessern Governance und Nachvollziehbarkeit für Fabric-Datenprodukte?'),
      [
        o('A', 'Apply sensitivity labels to important items', 'Wenden Sie Vertraulichkeitsbezeichnungen auf wichtige Elemente an'),
        o('B', 'Use lineage and catalog features to trace upstream and downstream dependencies', 'Verwenden Sie Lineage- und Katalogfunktionen, um Upstream- und Downstream-Abhängigkeiten nachzuverfolgen'),
        o('C', 'Store the system of record on local desktops', 'Speichern Sie das führende System auf lokalen Desktops'),
        o('D', 'Give every user Admin rights to all workspaces', 'Geben Sie jedem Benutzer Administratorrechte für alle Arbeitsbereiche')
      ],
      ['A', 'B'],
      t('Sensitivity labels improve classification, while lineage improves traceability and impact analysis. Local desktop copies and broad admin rights weaken governance.', 'Vertraulichkeitsbezeichnungen verbessern die Klassifizierung, während Lineage die Nachvollziehbarkeit und Auswirkungsanalyse verbessert. Lokale Desktop-Kopien und weitreichende Administratorrechte schwächen die Governance.'),
      t('Choose classification plus lineage.', 'Wählen Sie Klassifizierung plus Lineage.'),
      ref.catalog),

    q('dp700-321', 'single', prepare, 'easy', null,
      t('Why would an analyst use the SQL analytics endpoint of a Lakehouse?', 'Warum würde ein Analyst den SQL-Analyseendpunkt eines Lakehouse verwenden?'),
      [
        o('A', 'To query Delta tables with T-SQL without moving the data', 'Um Delta-Tabellen mit T-SQL abzufragen, ohne die Daten zu verschieben'),
        o('B', 'To configure tenant settings', 'Um Mandanteneinstellungen zu konfigurieren'),
        o('C', 'To create KQL dashboards', 'Um KQL-Dashboards zu erstellen'),
        o('D', 'To assign workspace roles', 'Um Arbeitsbereichsrollen zuzuweisen')
      ],
      ['A'],
      t('The SQL analytics endpoint exposes a SQL surface over lakehouse Delta tables. That lets SQL users analyze the same data without creating another copy.', 'Der SQL-Analyseendpunkt stellt eine SQL-Oberfläche über Delta-Tabellen des Lakehouse bereit. Dadurch können SQL-Benutzer dieselben Daten analysieren, ohne eine weitere Kopie zu erstellen.'),
      t('Think T-SQL over the same Delta data.', 'Denken Sie an T-SQL über dieselben Delta-Daten.'),
      ref.lakehouse),

    q('dp700-322', 'single', prepare, 'easy', null,
      t('Which Fabric capability uses Power Query for low-code ingestion and transformation and can load to Lakehouse or Warehouse?', 'Welche Fabric-Funktion verwendet Power Query für Low-Code-Aufnahme und -Transformation und kann in Lakehouse oder Warehouse laden?'),
      [
        o('A', 'Dataflows Gen2', 'Dataflows Gen2'),
        o('B', 'KQL Queryset', 'KQL-Queryset'),
        o('C', 'Deployment pipeline', 'Deployment-Pipeline'),
        o('D', 'Data Activator', 'Data Activator')
      ],
      ['A'],
      t('Dataflows Gen2 provide a low-code ETL experience based on Power Query and support multiple destinations in Fabric.', 'Dataflows Gen2 bieten eine Low-Code-ETL-Erfahrung auf Basis von Power Query und unterstützen mehrere Ziele in Fabric.'),
      t('Choose the low-code Power Query option.', 'Wählen Sie die Low-Code-Power-Query-Option.'),
      ref.dataflows),

    q('dp700-323', 'multiple', prepare, 'hard',
      t('Nightly SFTP files must land in bronze, be transformed to silver, and then loaded into a warehouse table. Failed steps must be rerunnable without repeating successful ones.', 'Nächtliche SFTP-Dateien müssen in Bronze landen, nach Silver transformiert und dann in eine Warehouse-Tabelle geladen werden. Fehlgeschlagene Schritte sollen erneut ausführbar sein, ohne erfolgreiche zu wiederholen.'),
      t('Which two Fabric capabilities should you combine?', 'Welche zwei Fabric-Funktionen sollten Sie kombinieren?'),
      [
        o('A', 'Data pipeline activities with dependencies and retry policies', 'Data-Pipeline-Aktivitäten mit Abhängigkeiten und Wiederholungsrichtlinien'),
        o('B', 'Notebooks or Dataflows Gen2 for transformations', 'Notebooks oder Dataflows Gen2 für Transformationen'),
        o('C', 'Bookmarks for orchestration', 'Lesezeichen zur Orchestrierung'),
        o('D', 'A dashboard as the retry engine', 'Ein Dashboard als Wiederholungs-Engine')
      ],
      ['A', 'B'],
      t('Pipelines orchestrate multi-step batch workflows with retries and dependencies, while notebooks or Dataflows Gen2 perform the data preparation logic.', 'Pipelines orchestrieren mehrstufige Batch-Workflows mit Wiederholungen und Abhängigkeiten, während Notebooks oder Dataflows Gen2 die Datenaufbereitung ausführen.'),
      t('Use an orchestrator plus a transformation engine.', 'Verwenden Sie einen Orchestrator plus eine Transformations-Engine.'),
      ref.pipelines),

    q('dp700-324', 'single', prepare, 'medium', null,
      t('In a medallion architecture, what is the main purpose of the silver layer?', 'Was ist in einer Medallion-Architektur der Hauptzweck der Silver-Schicht?'),
      [
        o('A', 'Store raw unchanged source extracts only', 'Nur rohe unveränderte Quellauszüge speichern'),
        o('B', 'Hold cleansed and conformed data ready for downstream modeling', 'Bereinigte und harmonisierte Daten für die nachgelagerte Modellierung bereithalten'),
        o('C', 'Contain only final paginated reports', 'Nur finale paginierte Berichte enthalten'),
        o('D', 'Replace workspace governance', 'Arbeitsbereichs-Governance ersetzen')
      ],
      ['B'],
      t('The silver layer is where raw data is cleaned, standardized, deduplicated, and prepared for reusable analytics patterns. It sits between raw bronze and business-ready gold.', 'Die Silver-Schicht ist der Bereich, in dem Rohdaten bereinigt, standardisiert, dedupliziert und für wiederverwendbare Analyse-Muster vorbereitet werden. Sie liegt zwischen roher Bronze und fachlich nutzbarem Gold.'),
      t('Bronze is raw, gold is business-ready.', 'Bronze ist roh, Gold ist fachlich nutzbar.'),
      ref.lakehouse),

    q('dp700-325', 'single', prepare, 'medium',
      t('You run this PySpark code in a Fabric notebook:\n\ndf.write.mode("overwrite").format("delta").saveAsTable("silver.sales")', 'Sie führen diesen PySpark-Code in einem Fabric-Notebook aus:\n\ndf.write.mode("overwrite").format("delta").saveAsTable("silver.sales")'),
      t('What does this code do?', 'Was macht dieser Code?'),
      [
        o('A', 'It writes the DataFrame as a Delta table named silver.sales', 'Er schreibt den DataFrame als Delta-Tabelle mit dem Namen silver.sales'),
        o('B', 'It exports the DataFrame to Excel', 'Er exportiert den DataFrame nach Excel'),
        o('C', 'It creates a DirectQuery semantic model', 'Er erstellt ein DirectQuery-semantisches Modell'),
        o('D', 'It mirrors an Azure SQL database', 'Er spiegelt eine Azure-SQL-Datenbank')
      ],
      ['A'],
      t('The code saves the DataFrame as a managed Delta table in the lakehouse. Delta format supports ACID transactions and efficient analytics over open files.', 'Der Code speichert den DataFrame als verwaltete Delta-Tabelle im Lakehouse. Das Delta-Format unterstützt ACID-Transaktionen und effiziente Analysen über offene Dateien.'),
      t('Focus on format("delta") and saveAsTable.', 'Achten Sie auf format("delta") und saveAsTable.'),
      ref.delta),

    q('dp700-326', 'single', prepare, 'medium',
      t('A Fabric warehouse uses the following T-SQL pattern:\n\nMERGE INTO dbo.Customer AS tgt\nUSING staging.Customer AS src\nON tgt.CustomerID = src.CustomerID\nWHEN MATCHED THEN UPDATE SET tgt.City = src.City\nWHEN NOT MATCHED THEN INSERT (CustomerID, City) VALUES (src.CustomerID, src.City);', 'Ein Fabric Warehouse verwendet folgendes T-SQL-Muster:\n\nMERGE INTO dbo.Customer AS tgt\nUSING staging.Customer AS src\nON tgt.CustomerID = src.CustomerID\nWHEN MATCHED THEN UPDATE SET tgt.City = src.City\nWHEN NOT MATCHED THEN INSERT (CustomerID, City) VALUES (src.CustomerID, src.City);'),
      t('What is the main purpose of this statement?', 'Was ist der Hauptzweck dieser Anweisung?'),
      [
        o('A', 'Upsert new and changed rows from staging into the target table', 'Neue und geänderte Zeilen aus der Staging-Tabelle in die Zieltabelle per Upsert übertragen'),
        o('B', 'Create a KQL dashboard', 'Ein KQL-Dashboard erstellen'),
        o('C', 'Enable RLS', 'RLS aktivieren'),
        o('D', 'Mark a date table', 'Eine Datumstabelle markieren')
      ],
      ['A'],
      t('MERGE is used for warehouse ELT patterns where changed rows must be updated and new rows inserted in one statement.', 'MERGE wird in Warehouse-ELT-Mustern verwendet, wenn geänderte Zeilen aktualisiert und neue Zeilen in einer einzigen Anweisung eingefügt werden sollen.'),
      t('Think update plus insert in one operation.', 'Denken Sie an Aktualisierung plus Einfügen in einem Vorgang.'),
      ref.queryWarehouse),

    q('dp700-327', 'single', prepare, 'medium',
      t('Your Fabric solution must expose files stored in Amazon S3 without increasing storage cost through copied datasets.', 'Ihre Fabric-Lösung muss in Amazon S3 gespeicherte Dateien bereitstellen, ohne die Speicherkosten durch kopierte Datasets zu erhöhen.'),
      t('Which capability is most appropriate?', 'Welche Funktion ist am geeignetsten?'),
      [
        o('A', 'OneLake shortcut', 'OneLake-Shortcut'),
        o('B', 'Import mode semantic model', 'Semantisches Modell im Importmodus'),
        o('C', 'Paginated report subscription', 'Abonnement für paginierten Bericht'),
        o('D', 'Calculation group', 'Berechnungsgruppe')
      ],
      ['A'],
      t('Shortcuts are designed for virtualization of external data access. They reduce duplication and let users work with the data through Fabric.', 'Shortcuts sind für die Virtualisierung des Zugriffs auf externe Daten ausgelegt. Sie reduzieren Duplizierung und ermöglichen Benutzern die Arbeit mit den Daten über Fabric.'),
      t('Avoid the answer that creates another copy.', 'Vermeiden Sie die Antwort, die eine weitere Kopie erstellt.'),
      ref.shortcuts),

    q('dp700-328', 'single', prepare, 'medium',
      t('You need near real-time analytics over operational tables and want Fabric to maintain replicated copies for downstream use.', 'Sie benötigen nahezu Echtzeitanalysen über operative Tabellen und möchten, dass Fabric replizierte Kopien für die nachgelagerte Nutzung verwaltet.'),
      t('What should you use?', 'Was sollten Sie verwenden?'),
      [
        o('A', 'Mirroring', 'Mirroring'),
        o('B', 'Bookmark navigator', 'Lesezeichen-Navigator'),
        o('C', 'RLS role', 'RLS-Rolle'),
        o('D', 'Q&A visual', 'Q&A-Visual')
      ],
      ['A'],
      t('Mirroring continuously replicates supported operational sources into Fabric so analytics workloads can read local copies with low latency.', 'Mirroring repliziert unterstützte operative Quellen fortlaufend nach Fabric, sodass Analyse-Workloads lokale Kopien mit geringer Latenz lesen können.'),
      t('Replicated copies point to mirroring.', 'Replizierte Kopien weisen auf Mirroring hin.'),
      ref.mirroring),

    q('dp700-329', 'single', prepare, 'medium',
      t('A manufacturing solution must ingest sensor messages continuously and route them for real-time analytics in Fabric.', 'Eine Fertigungslösung muss Sensormeldungen kontinuierlich aufnehmen und für Echtzeitanalysen in Fabric weiterleiten.'),
      t('Which Fabric item is designed for this pattern?', 'Welches Fabric-Element ist für dieses Muster ausgelegt?'),
      [
        o('A', 'Eventstream', 'Eventstream'),
        o('B', 'Deployment pipeline', 'Deployment-Pipeline'),
        o('C', 'Paginated report', 'Paginierter Bericht'),
        o('D', 'Workspace role', 'Arbeitsbereichsrolle')
      ],
      ['A'],
      t('Eventstream is the Fabric capability for ingesting, transforming, and routing streaming events into real-time analytics destinations.', 'Eventstream ist die Fabric-Funktion zum Aufnehmen, Transformieren und Weiterleiten von Streaming-Ereignissen in Ziele für Echtzeitanalysen.'),
      t('Think streaming ingestion, not batch orchestration.', 'Denken Sie an Streaming-Aufnahme und nicht an Batch-Orchestrierung.'),
      ref.eventstream),

    q('dp700-330', 'single', prepare, 'medium', null,
      t('Why is a star schema recommended for analytics models built on warehouse or lakehouse data?', 'Warum wird für Analysemodelle auf Warehouse- oder Lakehouse-Daten ein Sternschema empfohlen?'),
      [
        o('A', 'It usually simplifies filtering and improves usability for BI consumers', 'Es vereinfacht in der Regel die Filterung und verbessert die Nutzbarkeit für BI-Konsumenten'),
        o('B', 'It removes the need for dimension tables', 'Es entfernt die Notwendigkeit von Dimensionstabellen'),
        o('C', 'It forces every relationship to be many-to-many', 'Es zwingt jede Beziehung dazu, Viele-zu-Viele zu sein'),
        o('D', 'It requires only KQL queries', 'Es erfordert nur KQL-Abfragen')
      ],
      ['A'],
      t('A star schema separates facts and dimensions clearly, which makes reporting logic easier to understand and often performs better in semantic models.', 'Ein Sternschema trennt Fakten und Dimensionen klar, was die Berichtslogik leichter verständlich macht und in semantischen Modellen oft besser performt.'),
      t('Think fact table plus reusable dimensions.', 'Denken Sie an Faktentabelle plus wiederverwendbare Dimensionen.'),
      ref.star),

    q('dp700-331', 'single', prepare, 'medium', null,
      t('Why would you optimize Delta tables and use V-Order in Fabric when appropriate?', 'Warum würden Sie Delta-Tabellen optimieren und V-Order in Fabric verwenden, wenn es sinnvoll ist?'),
      [
        o('A', 'To improve read efficiency and query performance on analytical workloads', 'Um die Leseeffizienz und Abfrageleistung für analytische Workloads zu verbessern'),
        o('B', 'To convert Delta tables into dashboards', 'Um Delta-Tabellen in Dashboards umzuwandeln'),
        o('C', 'To disable ACID transactions', 'Um ACID-Transaktionen zu deaktivieren'),
        o('D', 'To mark a table as a dimension automatically', 'Um eine Tabelle automatisch als Dimension zu markieren')
      ],
      ['A'],
      t('Delta optimization and V-Order can improve scan efficiency and performance for analytics over lakehouse tables. They are storage and layout optimizations, not modeling features.', 'Delta-Optimierung und V-Order können die Scan-Effizienz und Leistung für Analysen über Lakehouse-Tabellen verbessern. Es sind Speicher- und Layoutoptimierungen und keine Modellierungsfunktionen.'),
      t('Think storage optimization for reads.', 'Denken Sie an Speicheroptimierung für Lesezugriffe.'),
      ref.vorder),

    q('dp700-332', 'single', prepare, 'medium',
      t('You run this PySpark code:\n\nclean_df = raw_df.dropDuplicates(["OrderId"])', 'Sie führen diesen PySpark-Code aus:\n\nclean_df = raw_df.dropDuplicates(["OrderId"])'),
      t('What is the intent of this transformation?', 'Was ist die Absicht dieser Transformation?'),
      [
        o('A', 'Keep a single row per OrderId in the resulting DataFrame', 'Im resultierenden DataFrame nur eine Zeile pro OrderId beibehalten'),
        o('B', 'Sort the DataFrame by OrderId descending', 'Den DataFrame nach OrderId absteigend sortieren'),
        o('C', 'Convert the column to DirectQuery mode', 'Die Spalte in den DirectQuery-Modus konvertieren'),
        o('D', 'Create a deployment pipeline rule', 'Eine Bereitstellungsregel erstellen')
      ],
      ['A'],
      t('dropDuplicates removes duplicate records based on the specified columns. This is a common silver-layer cleansing step.', 'dropDuplicates entfernt doppelte Datensätze basierend auf den angegebenen Spalten. Dies ist ein typischer Bereinigungsschritt in der Silver-Schicht.'),
      t('The method name says what happens.', 'Der Methodenname sagt, was passiert.'),
      ref.notebook),

    q('dp700-333', 'multiple', prepare, 'medium', null,
      t('Which two statements are true when choosing between notebooks and Dataflows Gen2?', 'Welche zwei Aussagen sind richtig, wenn Sie zwischen Notebooks und Dataflows Gen2 wählen?'),
      [
        o('A', 'Notebooks are a good fit for custom code and PySpark transformations', 'Notebooks eignen sich gut für benutzerdefinierten Code und PySpark-Transformationen'),
        o('B', 'Dataflows Gen2 provide a low-code Power Query experience', 'Dataflows Gen2 bieten eine Low-Code-Erfahrung mit Power Query'),
        o('C', 'Notebooks can run only SQL and never Python', 'Notebooks können nur SQL und niemals Python ausführen'),
        o('D', 'Dataflows Gen2 are used only for streaming telemetry', 'Dataflows Gen2 werden nur für Streaming-Telemetrie verwendet')
      ],
      ['A', 'B'],
      t('Notebooks are code-first and support Spark languages such as Python, while Dataflows Gen2 are low-code and Power Query based. Neither statement C nor D is correct.', 'Notebooks sind code-first und unterstützen Spark-Sprachen wie Python, während Dataflows Gen2 Low-Code-basiert und auf Power Query aufgebaut sind. Weder Aussage C noch D ist korrekt.'),
      t('One answer is code-first, the other is low-code.', 'Eine Antwort ist code-first, die andere ist low-code.'),
      ref.dataflows),

    q('dp700-334', 'single', prepare, 'medium',
      t('A BI team wants curated relational tables, T-SQL transformations, and SQL-centric development for departmental reporting.', 'Ein BI-Team möchte kuratierte relationale Tabellen, T-SQL-Transformationen und SQL-zentrierte Entwicklung für Abteilungsberichte.'),
      t('Which Fabric item should they choose?', 'Welches Fabric-Element sollten sie wählen?'),
      [
        o('A', 'Warehouse', 'Warehouse'),
        o('B', 'Eventstream', 'Eventstream'),
        o('C', 'Data Activator', 'Data Activator'),
        o('D', 'Drillthrough page', 'Drillthrough-Seite')
      ],
      ['A'],
      t('Warehouse is the SQL-first Fabric experience for relational analytics and curated reporting datasets.', 'Warehouse ist die SQL-zentrierte Fabric-Erfahrung für relationale Analysen und kuratierte Reporting-Datasets.'),
      t('Choose the relational SQL engine.', 'Wählen Sie die relationale SQL-Engine.'),
      ref.warehouse),

    q('dp700-335', 'single', prepare, 'hard',
      t('You use the following T-SQL in a Fabric warehouse:\n\nCREATE TABLE dbo.MonthlySales AS\nSELECT CalendarMonth, SUM(SalesAmount) AS SalesAmount\nFROM dbo.FactSales\nGROUP BY CalendarMonth;', 'Sie verwenden folgendes T-SQL in einem Fabric Warehouse:\n\nCREATE TABLE dbo.MonthlySales AS\nSELECT CalendarMonth, SUM(SalesAmount) AS SalesAmount\nFROM dbo.FactSales\nGROUP BY CalendarMonth;'),
      t('Why is this pattern useful in ELT processes?', 'Warum ist dieses Muster in ELT-Prozessen nützlich?'),
      [
        o('A', 'It creates and loads a transformed table in one step', 'Es erstellt und lädt eine transformierte Tabelle in einem Schritt'),
        o('B', 'It enables row-level security automatically', 'Es aktiviert automatisch Row-Level Security'),
        o('C', 'It turns the warehouse into a lakehouse', 'Es verwandelt das Warehouse in ein Lakehouse'),
        o('D', 'It publishes a Power BI app', 'Es veröffentlicht eine Power-BI-App')
      ],
      ['A'],
      t('CTAS-style patterns are useful because they materialize transformed results directly into a new table. That is common in warehouse ELT workloads.', 'CTAS-ähnliche Muster sind nützlich, weil sie transformierte Ergebnisse direkt in eine neue Tabelle materialisieren. Das ist typisch für ELT-Workloads im Warehouse.'),
      t('Read the first three words carefully: create table as.', 'Lesen Sie die ersten drei Wörter genau: create table as.'),
      ref.queryWarehouse),

    q('dp700-336', 'single', prepare, 'medium', null,
      t('Which Fabric item combines file-based OneLake storage with Spark access and a SQL endpoint over the same Delta tables?', 'Welches Fabric-Element kombiniert dateibasierte OneLake-Speicherung mit Spark-Zugriff und einem SQL-Endpunkt über dieselben Delta-Tabellen?'),
      [
        o('A', 'Lakehouse', 'Lakehouse'),
        o('B', 'Q&A visual', 'Q&A-Visual'),
        o('C', 'Deployment pipeline', 'Deployment-Pipeline'),
        o('D', 'Security group', 'Sicherheitsgruppe')
      ],
      ['A'],
      t('Lakehouse is designed to serve both data engineering and SQL analytics over shared Delta data.', 'Das Lakehouse ist darauf ausgelegt, sowohl Data Engineering als auch SQL-Analysen über gemeinsame Delta-Daten zu bedienen.'),
      t('Think open files plus two engines.', 'Denken Sie an offene Dateien plus zwei Engines.'),
      ref.lakehouse),

    q('dp700-337', 'multiple', prepare, 'medium', null,
      t('Which two advantages are common reasons to use OneLake shortcuts?', 'Welche zwei Vorteile sind typische Gründe für die Verwendung von OneLake-Shortcuts?'),
      [
        o('A', 'Reduce data duplication across analytics estates', 'Datenverdopplung über Analyseumgebungen hinweg reduzieren'),
        o('B', 'Expose existing external data through Fabric', 'Vorhandene externe Daten über Fabric bereitstellen'),
        o('C', 'Automatically convert all files to semantic models', 'Alle Dateien automatisch in semantische Modelle umwandeln'),
        o('D', 'Replace RLS and OLS', 'RLS und OLS ersetzen')
      ],
      ['A', 'B'],
      t('Shortcuts help avoid needless copies and give Fabric access to data that already exists elsewhere. They do not replace semantic modeling or security features.', 'Shortcuts helfen, unnötige Kopien zu vermeiden, und ermöglichen Fabric den Zugriff auf Daten, die bereits an anderer Stelle existieren. Sie ersetzen weder semantische Modellierung noch Sicherheitsfunktionen.'),
      t('Both correct answers are about less duplication and more access.', 'Beide richtigen Antworten betreffen weniger Duplizierung und mehr Zugriff.'),
      ref.shortcuts),

    q('dp700-338', 'single', prepare, 'medium',
      t('A real-time solution must continuously ingest device events and then analyze them with low latency in a KQL-based experience.', 'Eine Echtzeitlösung muss Geräteereignisse kontinuierlich aufnehmen und anschließend mit geringer Latenz in einer KQL-basierten Erfahrung analysieren.'),
      t('Which ingestion component should be used first?', 'Welche Aufnahmekomponente sollte zuerst verwendet werden?'),
      [
        o('A', 'Eventstream', 'Eventstream'),
        o('B', 'Paginated report', 'Paginierter Bericht'),
        o('C', 'Import semantic model', 'Semantisches Modell im Importmodus'),
        o('D', 'Workspace domain assignment', 'Arbeitsbereichs-Domänenzuweisung')
      ],
      ['A'],
      t('Eventstream is built for streaming ingestion and routing into real-time analytics destinations, including KQL-based workloads.', 'Eventstream ist für Streaming-Aufnahme und Weiterleitung in Ziele für Echtzeitanalysen einschließlich KQL-basierter Workloads konzipiert.'),
      t('Start with the stream ingestion service.', 'Beginnen Sie mit dem Streaming-Aufnahmedienst.'),
      ref.eventstream),

    q('dp700-339', 'single', prepare, 'easy',
      t('You run this SQL query in a Fabric warehouse:\n\nSELECT CustomerKey, SUM(SalesAmount) AS SalesTotal\nFROM dbo.FactSales\nGROUP BY CustomerKey;', 'Sie führen diese SQL-Abfrage in einem Fabric Warehouse aus:\n\nSELECT CustomerKey, SUM(SalesAmount) AS SalesTotal\nFROM dbo.FactSales\nGROUP BY CustomerKey;'),
      t('What does the result contain?', 'Was enthält das Ergebnis?'),
      [
        o('A', 'One aggregated row per CustomerKey', 'Eine aggregierte Zeile pro CustomerKey'),
        o('B', 'One row per original sales transaction', 'Eine Zeile pro ursprünglicher Verkaufstransaktion'),
        o('C', 'Only customers with zero sales', 'Nur Kunden ohne Umsatz'),
        o('D', 'A list of semantic model relationships', 'Eine Liste semantischer Modellbeziehungen')
      ],
      ['A'],
      t('GROUP BY CustomerKey collapses the fact rows into one aggregated row per customer and returns the summed sales amount for that grain.', 'GROUP BY CustomerKey fasst die Faktzeilen zu einer aggregierten Zeile pro Kunde zusammen und liefert die summierte Umsatzmenge für diese Granularität.'),
      t('Look at the grouping column.', 'Achten Sie auf die Gruppierungsspalte.'),
      ref.queryWarehouse),

    q('dp700-340', 'single', prepare, 'medium', null,
      t('In a medallion design, which layer should contain trusted business-ready tables that semantic models can consume directly?', 'Welche Schicht sollte in einem Medallion-Design vertrauenswürdige fachlich nutzbare Tabellen enthalten, die semantische Modelle direkt verwenden können?'),
      [
        o('A', 'Bronze', 'Bronze'),
        o('B', 'Silver', 'Silver'),
        o('C', 'Gold', 'Gold'),
        o('D', 'Raw landing only', 'Nur Roh-Landing')
      ],
      ['C'],
      t('Gold is the curated consumption layer intended for business-ready entities and downstream analytics.', 'Gold ist die kuratierte Konsumschicht für fachlich nutzbare Entitäten und nachgelagerte Analysen.'),
      t('Gold is closest to the business.', 'Gold ist am nächsten am Fachbereich.'),
      ref.lakehouse),

    q('dp700-341', 'single', semantic, 'easy', null,
      t('Which semantic-model storage mode usually provides the fastest query performance when the full dataset can be loaded into the model?', 'Welcher Speichermodus für semantische Modelle bietet in der Regel die schnellste Abfrageleistung, wenn das vollständige Dataset in das Modell geladen werden kann?'),
      [
        o('A', 'Import', 'Import'),
        o('B', 'DirectQuery', 'DirectQuery'),
        o('C', 'Live XMLA only', 'Nur Live-XMLA'),
        o('D', 'Paginated', 'Paginierter Bericht')
      ],
      ['A'],
      t('Import mode stores data inside the model, which usually gives the best interactive query performance when refresh latency is acceptable.', 'Der Importmodus speichert Daten im Modell, was in der Regel die beste interaktive Abfrageleistung bietet, wenn die Aktualisierungslatenz akzeptabel ist.'),
      t('Fastest queries usually come from cached model data.', 'Die schnellsten Abfragen kommen in der Regel aus zwischengespeicherten Modelldaten.'),
      ref.modelModes),

    q('dp700-342', 'single', semantic, 'medium',
      t('A source database changes every few minutes, and users must see current values without waiting for an import refresh.', 'Eine Quelldatenbank ändert sich alle paar Minuten, und Benutzer müssen aktuelle Werte sehen, ohne auf eine Importaktualisierung zu warten.'),
      t('Which semantic-model mode best fits?', 'Welcher Modus für semantische Modelle passt am besten?'),
      [
        o('A', 'DirectQuery', 'DirectQuery'),
        o('B', 'Import only', 'Nur Import'),
        o('C', 'CSV export mode', 'CSV-Exportmodus'),
        o('D', 'Bookmark mode', 'Lesezeichenmodus')
      ],
      ['A'],
      t('DirectQuery pushes queries to the source at query time, which helps when data freshness is more important than import-style performance.', 'DirectQuery sendet Abfragen zur Abfragezeit an die Quelle, was hilfreich ist, wenn Datenaktualität wichtiger ist als importähnliche Leistung.'),
      t('Fresh data without refresh points to DirectQuery.', 'Frische Daten ohne Refresh weisen auf DirectQuery hin.'),
      ref.directQuery),

    q('dp700-343', 'single', semantic, 'medium',
      t('What is a major benefit of DirectLake for semantic models built on Fabric data?', 'Was ist ein wesentlicher Vorteil von DirectLake für semantische Modelle auf Fabric-Daten?'),
      t('Which answer is correct?', 'Welche Antwort ist richtig?'),
      [
        o('A', 'It can provide import-like performance over Fabric data without a traditional data import copy', 'Es kann importähnliche Leistung über Fabric-Daten ohne eine traditionelle Datenimportkopie bieten'),
        o('B', 'It works only with external Oracle files', 'Es funktioniert nur mit externen Oracle-Dateien'),
        o('C', 'It removes the need for relationships', 'Es entfernt die Notwendigkeit von Beziehungen'),
        o('D', 'It requires every table to use KQL', 'Es erfordert, dass jede Tabelle KQL verwendet')
      ],
      ['A'],
      t('DirectLake is optimized for Fabric data in OneLake and can deliver fast performance without loading a separate import copy into the semantic model.', 'DirectLake ist für Fabric-Daten in OneLake optimiert und kann schnelle Leistung liefern, ohne eine separate Importkopie in das semantische Modell zu laden.'),
      t('Think fast access over Fabric-resident data.', 'Denken Sie an schnellen Zugriff auf in Fabric gespeicherte Daten.'),
      ref.directLake),

    q('dp700-344', 'single', semantic, 'medium', null,
      t('What is a composite model in Power BI and Fabric?', 'Was ist ein zusammengesetztes Modell in Power BI und Fabric?'),
      [
        o('A', 'A model that can combine tables from Import and DirectQuery sources', 'Ein Modell, das Tabellen aus Import- und DirectQuery-Quellen kombinieren kann'),
        o('B', 'A model that contains only bookmarked visuals', 'Ein Modell, das nur mit Lesezeichen versehene Visuals enthält'),
        o('C', 'A model that supports only paginated reports', 'Ein Modell, das nur paginierte Berichte unterstützt'),
        o('D', 'A model that disables relationships', 'Ein Modell, das Beziehungen deaktiviert')
      ],
      ['A'],
      t('Composite models allow different storage behaviors in one model, such as Import for some tables and DirectQuery for others.', 'Zusammengesetzte Modelle erlauben unterschiedliche Speicherverhalten in einem Modell, zum Beispiel Import für einige Tabellen und DirectQuery für andere.'),
      t('The word composite implies mixed sources or modes.', 'Das Wort zusammengesetzt deutet auf gemischte Quellen oder Modi hin.'),
      ref.composite),

    q('dp700-345', 'single', semantic, 'medium', null,
      t('What is the main purpose of the DAX CALCULATE function?', 'Was ist der Hauptzweck der DAX-Funktion CALCULATE?'),
      [
        o('A', 'Modify filter context before evaluating an expression', 'Den Filterkontext ändern, bevor ein Ausdruck ausgewertet wird'),
        o('B', 'Create a workspace role', 'Eine Arbeitsbereichsrolle erstellen'),
        o('C', 'Load parquet files into OneLake', 'Parquet-Dateien in OneLake laden'),
        o('D', 'Write Spark code', 'Spark-Code schreiben')
      ],
      ['A'],
      t('CALCULATE is the core DAX function for changing filter context and then evaluating an expression under that modified context.', 'CALCULATE ist die zentrale DAX-Funktion, um den Filterkontext zu ändern und dann einen Ausdruck unter diesem geänderten Kontext auszuwerten.'),
      t('CALCULATE changes how the measure is filtered.', 'CALCULATE ändert, wie das Measure gefiltert wird.'),
      ref.daxCalculate),

    q('dp700-346', 'single', semantic, 'medium',
      t('You define this measure:\n\nBlue Sales = CALCULATE([Sales Amount], Product[Color] = "Blue")', 'Sie definieren dieses Measure:\n\nBlue Sales = CALCULATE([Sales Amount], Product[Color] = "Blue")'),
      t('What does the measure return?', 'Was liefert das Measure zurück?'),
      [
        o('A', 'Sales Amount filtered to products where Color is Blue', 'Sales Amount gefiltert auf Produkte, deren Farbe Blau ist'),
        o('B', 'All sales regardless of color', 'Alle Verkäufe unabhängig von der Farbe'),
        o('C', 'Only rows where the product is missing', 'Nur Zeilen, in denen das Produkt fehlt'),
        o('D', 'A list of all product colors', 'Eine Liste aller Produktfarben')
      ],
      ['A'],
      t('The filter argument inside CALCULATE changes context so the measure evaluates only for blue products.', 'Das Filterargument innerhalb von CALCULATE ändert den Kontext, sodass das Measure nur für blaue Produkte ausgewertet wird.'),
      t('Read the filter argument after the comma.', 'Lesen Sie das Filterargument nach dem Komma.'),
      ref.daxCalculate),

    q('dp700-347', 'single', semantic, 'hard',
      t('You define this measure:\n\nPct of All Sales = DIVIDE([Sales Amount], CALCULATE([Sales Amount], ALL(Product)))', 'Sie definieren dieses Measure:\n\nPct of All Sales = DIVIDE([Sales Amount], CALCULATE([Sales Amount], ALL(Product)))'),
      t('What is the role of ALL(Product) in the denominator?', 'Welche Rolle spielt ALL(Product) im Nenner?'),
      [
        o('A', 'It removes product filters so the denominator represents sales across all products', 'Es entfernt Produktfilter, sodass der Nenner Verkäufe über alle Produkte hinweg darstellt'),
        o('B', 'It returns only products with blank values', 'Es liefert nur Produkte mit leeren Werten zurück'),
        o('C', 'It activates an inactive relationship', 'Es aktiviert eine inaktive Beziehung'),
        o('D', 'It converts the measure to DirectQuery', 'Es konvertiert das Measure zu DirectQuery')
      ],
      ['A'],
      t('ALL removes filters from the specified table or column, which is a common way to build percent-of-total measures.', 'ALL entfernt Filter von der angegebenen Tabelle oder Spalte, was ein gängiger Weg ist, um Prozent-vom-Gesamt-Measure zu erstellen.'),
      t('Think denominator without the product filter.', 'Denken Sie an einen Nenner ohne Produktfilter.'),
      ref.daxAll),

    q('dp700-348', 'single', semantic, 'hard',
      t('You create this measure:\n\nDelivery Sales = CALCULATE([Sales Amount], USERELATIONSHIP(\'Date\'[Date], Sales[DeliveryDate]))', 'Sie erstellen dieses Measure:\n\nDelivery Sales = CALCULATE([Sales Amount], USERELATIONSHIP(\'Date\'[Date], Sales[DeliveryDate]))'),
      t('What does USERELATIONSHIP do here?', 'Was macht USERELATIONSHIP hier?'),
      [
        o('A', 'It temporarily activates the relationship that uses DeliveryDate for this calculation', 'Es aktiviert für diese Berechnung vorübergehend die Beziehung, die DeliveryDate verwendet'),
        o('B', 'It creates a new table in OneLake', 'Es erstellt eine neue Tabelle in OneLake'),
        o('C', 'It hides the Date table from users', 'Es blendet die Datumstabelle für Benutzer aus'),
        o('D', 'It removes filter context completely', 'Es entfernt den Filterkontext vollständig')
      ],
      ['A'],
      t('USERELATIONSHIP lets a measure use an inactive relationship during evaluation, which is useful when one fact table has multiple date columns.', 'USERELATIONSHIP ermöglicht es einem Measure, während der Auswertung eine inaktive Beziehung zu verwenden. Das ist nützlich, wenn eine Faktentabelle mehrere Datumsspalten besitzt.'),
      t('Think alternate date relationship for one measure.', 'Denken Sie an eine alternative Datumsbeziehung für ein Measure.'),
      ref.daxUserRelationship),

    q('dp700-349', 'single', semantic, 'easy', null,
      t('What is the purpose of row-level security (RLS) in a semantic model?', 'Was ist der Zweck von Row-Level Security (RLS) in einem semantischen Modell?'),
      [
        o('A', 'Restrict which rows each user can see', 'Einschränken, welche Zeilen jeder Benutzer sehen kann'),
        o('B', 'Hide the entire table schema from all users', 'Das gesamte Tabellenschema vor allen Benutzern verbergen'),
        o('C', 'Increase notebook compute automatically', 'Notebook-Compute automatisch erhöhen'),
        o('D', 'Replace workspace roles', 'Arbeitsbereichsrollen ersetzen')
      ],
      ['A'],
      t('RLS filters data by user or role so each audience sees only the rows it is allowed to access.', 'RLS filtert Daten nach Benutzer oder Rolle, sodass jede Zielgruppe nur die Zeilen sieht, auf die sie zugreifen darf.'),
      t('RLS is about row filtering.', 'RLS betrifft das Filtern von Zeilen.'),
      ref.rls),

    q('dp700-350', 'single', semantic, 'medium', null,
      t('What does object-level security (OLS) protect in a semantic model?', 'Was schützt Object-Level Security (OLS) in einem semantischen Modell?'),
      [
        o('A', 'Tables or columns that should be hidden from certain users', 'Tabellen oder Spalten, die für bestimmte Benutzer verborgen sein sollen'),
        o('B', 'Only the report page background color', 'Nur die Hintergrundfarbe der Berichtsseite'),
        o('C', 'The refresh schedule only', 'Nur den Aktualisierungszeitplan'),
        o('D', 'Notebook cell execution history', 'Die Ausführungshistorie von Notebook-Zellen')
      ],
      ['A'],
      t('OLS hides secured objects such as tables or columns from users who are not allowed to see them. That complements row filtering with metadata and object protection.', 'OLS blendet geschützte Objekte wie Tabellen oder Spalten für Benutzer aus, die sie nicht sehen dürfen. Damit ergänzt es das Filtern von Zeilen durch Metadaten- und Objektschutz.'),
      t('OLS is about hiding objects, not filtering rows.', 'OLS betrifft das Verbergen von Objekten und nicht das Filtern von Zeilen.'),
      ref.ols),

    q('dp700-351', 'single', semantic, 'easy', null,
      t('Why do teams use deployment pipelines with Fabric and Power BI content?', 'Warum verwenden Teams Deployment Pipelines mit Fabric- und Power-BI-Inhalten?'),
      [
        o('A', 'To promote content through environments such as development, test, and production', 'Um Inhalte durch Umgebungen wie Entwicklung, Test und Produktion zu fördern'),
        o('B', 'To replace semantic model relationships', 'Um semantische Modellbeziehungen zu ersetzen'),
        o('C', 'To create OneLake shortcuts', 'Um OneLake-Shortcuts zu erstellen'),
        o('D', 'To write KQL automatically', 'Um KQL automatisch zu schreiben')
      ],
      ['A'],
      t('Deployment pipelines help manage controlled promotion of content across environments with reduced manual effort and better release discipline.', 'Deployment Pipelines helfen dabei, Inhalte kontrolliert über Umgebungen hinweg zu fördern, mit weniger manuellem Aufwand und besserer Release-Disziplin.'),
      t('Think Dev to Test to Prod.', 'Denken Sie an Dev zu Test zu Prod.'),
      ref.deployment),

    q('dp700-352', 'single', semantic, 'medium', null,
      t('What problem does incremental refresh solve for large semantic models?', 'Welches Problem löst die inkrementelle Aktualisierung für große semantische Modelle?'),
      [
        o('A', 'It avoids reloading unchanged historical partitions on every refresh', 'Sie vermeidet das erneute Laden unveränderter historischer Partitionen bei jeder Aktualisierung'),
        o('B', 'It removes the need for a date column', 'Sie entfernt die Notwendigkeit einer Datumsspalte'),
        o('C', 'It converts Import models to KQL', 'Sie konvertiert Importmodelle in KQL'),
        o('D', 'It replaces deployment pipelines', 'Sie ersetzt Deployment Pipelines')
      ],
      ['A'],
      t('Incremental refresh partitions the table by time and refreshes only the recent window, which reduces refresh duration and resource use.', 'Die inkrementelle Aktualisierung partitioniert die Tabelle nach Zeit und aktualisiert nur das jüngste Fenster. Dadurch werden Aktualisierungsdauer und Ressourcenverbrauch reduziert.'),
      t('The goal is less refresh work on old data.', 'Das Ziel ist weniger Aktualisierungsaufwand für alte Daten.'),
      ref.incremental),

    q('dp700-353', 'single', semantic, 'medium',
      t('A DirectQuery semantic model over a very large fact table needs faster performance for common high-level summary queries.', 'Ein DirectQuery-semantisches Modell über eine sehr große Faktentabelle benötigt bessere Leistung für häufige hoch aggregierte Abfragen.'),
      t('Which feature should you consider first?', 'Welche Funktion sollten Sie zuerst in Betracht ziehen?'),
      [
        o('A', 'Aggregations', 'Aggregationen'),
        o('B', 'Bookmarks', 'Lesezeichen'),
        o('C', 'Paginated subscriptions', 'Paginierte Abonnements'),
        o('D', 'Object-level security', 'Object-Level Security')
      ],
      ['A'],
      t('Aggregations accelerate summary-level queries by answering them from smaller pre-aggregated tables instead of always hitting the detailed source.', 'Aggregationen beschleunigen zusammenfassende Abfragen, indem sie diese aus kleineren voraggregierten Tabellen beantworten, statt immer die detaillierte Quelle abzufragen.'),
      t('Speed up summaries with pre-aggregated data.', 'Beschleunigen Sie Zusammenfassungen mit voraggregierten Daten.'),
      ref.aggregations),

    q('dp700-354', 'multiple', semantic, 'medium', null,
      t('Which two modeling practices are usually recommended in a star-schema semantic model?', 'Welche zwei Modellierungspraktiken werden in einem Sternschema für semantische Modelle in der Regel empfohlen?'),
      [
        o('A', 'Use dimension tables to filter fact tables', 'Verwenden Sie Dimensionstabellen, um Faktentabellen zu filtern'),
        o('B', 'Create clear business keys or surrogate keys for relationships', 'Erstellen Sie klare Geschäftsschlüssel oder Surrogatschlüssel für Beziehungen'),
        o('C', 'Connect every table to every other table directly', 'Verbinden Sie jede Tabelle direkt mit jeder anderen Tabelle'),
        o('D', 'Prefer many-to-many relationships everywhere', 'Bevorzugen Sie überall Viele-zu-Viele-Beziehungen')
      ],
      ['A', 'B'],
      t('Good star-schema practice means clear dimensions, clear relationships, and predictable filter propagation. Fully connected webs and pervasive many-to-many relationships usually hurt model clarity.', 'Gute Sternschema-Praxis bedeutet klare Dimensionen, klare Beziehungen und vorhersagbare Filterausbreitung. Vollständig vernetzte Strukturen und allgegenwärtige Viele-zu-Viele-Beziehungen verschlechtern normalerweise die Modellklarheit.'),
      t('Choose the answers that simplify filters and relationships.', 'Wählen Sie die Antworten, die Filter und Beziehungen vereinfachen.'),
      ref.relationships),

    q('dp700-355', 'single', semantic, 'medium', null,
      t('Why do DAX authors often use VAR in complex measures?', 'Warum verwenden DAX-Autoren in komplexen Measures häufig VAR?'),
      [
        o('A', 'To store intermediate results and improve readability', 'Um Zwischenergebnisse zu speichern und die Lesbarkeit zu verbessern'),
        o('B', 'To disable filter context', 'Um den Filterkontext zu deaktivieren'),
        o('C', 'To create a new workspace role', 'Um eine neue Arbeitsbereichsrolle zu erstellen'),
        o('D', 'To convert DirectLake to Import', 'Um DirectLake in Import zu konvertieren')
      ],
      ['A'],
      t('VAR lets you calculate an expression once, reuse it, and make the logic easier to read and maintain.', 'VAR ermöglicht es, einen Ausdruck einmal zu berechnen, wiederzuverwenden und die Logik leichter lesbar und wartbar zu machen.'),
      t('Think reusable intermediate values.', 'Denken Sie an wiederverwendbare Zwischenwerte.'),
      ref.daxVar),

    q('dp700-356', 'single', semantic, 'medium', null,
      t('What is required for reliable DAX time-intelligence calculations such as year-to-date?', 'Was ist für zuverlässige DAX-Time-Intelligence-Berechnungen wie Year-to-Date erforderlich?'),
      [
        o('A', 'A proper date table with contiguous dates and an appropriate relationship', 'Eine geeignete Datumstabelle mit lückenlosen Daten und einer passenden Beziehung'),
        o('B', 'A bookmark on every report page', 'Ein Lesezeichen auf jeder Berichtsseite'),
        o('C', 'Only many-to-many relationships', 'Nur Viele-zu-Viele-Beziehungen'),
        o('D', 'A paginated report parameter', 'Ein Parameter für einen paginierten Bericht')
      ],
      ['A'],
      t('Time-intelligence functions expect a well-formed date table and correct model relationships so they can evaluate date ranges consistently.', 'Time-Intelligence-Funktionen erwarten eine korrekt aufgebaute Datumstabelle und richtige Modellbeziehungen, damit Datumsbereiche konsistent ausgewertet werden können.'),
      t('Time intelligence starts with a real date table.', 'Time Intelligence beginnt mit einer echten Datumstabelle.'),
      ref.daxTime),

    q('dp700-357', 'single', semantic, 'medium',
      t('You define this measure:\n\nSales YTD = TOTALYTD([Sales Amount], \'Date\'[Date])', 'Sie definieren dieses Measure:\n\nSales YTD = TOTALYTD([Sales Amount], \'Date\'[Date])'),
      t('What does the measure return?', 'Was liefert das Measure zurück?'),
      [
        o('A', 'The cumulative Sales Amount from the start of the year to the current filter context date', 'Die kumulierte Sales Amount vom Jahresanfang bis zum aktuellen Datum im Filterkontext'),
        o('B', 'Only sales for the last completed month', 'Nur Verkäufe für den letzten abgeschlossenen Monat'),
        o('C', 'Sales for all years combined without filtering', 'Verkäufe für alle Jahre zusammen ohne Filterung'),
        o('D', 'A list of dates in the model', 'Eine Liste von Datumswerten im Modell')
      ],
      ['A'],
      t('TOTALYTD is a time-intelligence function that accumulates a measure from the beginning of the year up to the current context date.', 'TOTALYTD ist eine Time-Intelligence-Funktion, die ein Measure vom Beginn des Jahres bis zum aktuellen Datum im Kontext aufaddiert.'),
      t('YTD means year-to-date accumulation.', 'YTD bedeutet Aufsummierung seit Jahresbeginn.'),
      ref.daxTime),

    q('dp700-358', 'multiple', semantic, 'medium', null,
      t('Which two statements about DirectLake are correct?', 'Welche zwei Aussagen über DirectLake sind korrekt?'),
      [
        o('A', 'It is designed for semantic models over Fabric data in OneLake', 'Es ist für semantische Modelle über Fabric-Daten in OneLake ausgelegt'),
        o('B', 'It always requires a traditional scheduled import copy first', 'Es erfordert immer zuerst eine traditionelle geplante Importkopie'),
        o('C', 'It can provide very fast query performance over Fabric-resident data', 'Es kann sehr schnelle Abfrageleistung über in Fabric gespeicherte Daten liefern'),
        o('D', 'It eliminates the need for a semantic model entirely', 'Es macht ein semantisches Modell vollständig überflüssig')
      ],
      ['A', 'C'],
      t('DirectLake is built for Fabric data in OneLake and is intended to combine fast performance with minimal duplication. It does not remove the semantic model concept.', 'DirectLake ist für Fabric-Daten in OneLake konzipiert und soll schnelle Leistung mit minimaler Duplizierung verbinden. Es macht das Konzept des semantischen Modells nicht überflüssig.'),
      t('Pick Fabric data plus fast performance.', 'Wählen Sie Fabric-Daten plus schnelle Leistung.'),
      ref.directLake),

    q('dp700-359', 'single', semantic, 'medium', null,
      t('Why are calculation groups useful in large semantic models?', 'Warum sind Berechnungsgruppen in großen semantischen Modellen nützlich?'),
      [
        o('A', 'They reduce repeated measure logic, especially for patterns such as time intelligence', 'Sie reduzieren wiederholte Measure-Logik, insbesondere für Muster wie Time Intelligence'),
        o('B', 'They replace the need for dimensions', 'Sie ersetzen die Notwendigkeit von Dimensionen'),
        o('C', 'They load data from S3 directly', 'Sie laden Daten direkt aus S3'),
        o('D', 'They assign workspace permissions', 'Sie weisen Arbeitsbereichsberechtigungen zu')
      ],
      ['A'],
      t('Calculation groups centralize repeated calculation logic and help avoid creating many nearly identical measures.', 'Berechnungsgruppen zentralisieren wiederholte Berechnungslogik und helfen dabei, viele nahezu identische Measures zu vermeiden.'),
      t('Think reuse of calculation patterns.', 'Denken Sie an die Wiederverwendung von Berechnungsmustern.'),
      ref.calcGroups),

    q('dp700-360', 'single', semantic, 'hard',
      t('Customers can belong to multiple marketing segments, and report filters on segment must correctly affect sales results.', 'Kunden können mehreren Marketingsegmenten angehören, und Berichtfilter auf Segment müssen die Verkaufsergebnisse korrekt beeinflussen.'),
      t('What modeling approach is usually appropriate?', 'Welcher Modellierungsansatz ist in der Regel geeignet?'),
      [
        o('A', 'Use a bridge table between customers and segments', 'Verwenden Sie eine Bridge-Tabelle zwischen Kunden und Segmenten'),
        o('B', 'Remove the segment dimension completely', 'Entfernen Sie die Segmentdimension vollständig'),
        o('C', 'Store segments in report bookmarks only', 'Speichern Sie Segmente nur in Bericht-Lesezeichen'),
        o('D', 'Convert the fact table to a dashboard', 'Konvertieren Sie die Faktentabelle in ein Dashboard')
      ],
      ['A'],
      t('A bridge table is a common way to model many-to-many business relationships while preserving correct filter behavior in the semantic model.', 'Eine Bridge-Tabelle ist eine übliche Methode, um Viele-zu-Viele-Geschäftsbeziehungen zu modellieren und dabei korrektes Filterverhalten im semantischen Modell zu erhalten.'),
      t('Many-to-many business relationships often need a bridge.', 'Viele-zu-Viele-Geschäftsbeziehungen benötigen oft eine Bridge.'),
      ref.relationships),

    q('dp700-361', 'single', explore, 'easy', null,
      t('Which Fabric experience is best for exploratory data analysis where you want to write code, profile data, and inspect results interactively?', 'Welche Fabric-Erfahrung eignet sich am besten für explorative Datenanalyse, bei der Sie Code schreiben, Daten profilieren und Ergebnisse interaktiv prüfen möchten?'),
      [
        o('A', 'Notebook', 'Notebook'),
        o('B', 'Tenant settings', 'Mandanteneinstellungen'),
        o('C', 'Workspace role assignment', 'Arbeitsbereichs-Rollenzuweisung'),
        o('D', 'Sensitivity label', 'Vertraulichkeitsbezeichnung')
      ],
      ['A'],
      t('Notebooks are designed for interactive coding, experimentation, data profiling, and visualization in the same workspace experience.', 'Notebooks sind für interaktives Coding, Experimentieren, Datenprofiling und Visualisierung in derselben Arbeitsbereichserfahrung ausgelegt.'),
      t('Think interactive code plus data inspection.', 'Denken Sie an interaktiven Code plus Dateninspektion.'),
      ref.notebook),

    q('dp700-362', 'single', explore, 'easy', null,
      t('Which Fabric endpoint lets SQL users run ad hoc T-SQL against lakehouse Delta tables?', 'Welcher Fabric-Endpunkt ermöglicht SQL-Benutzern Ad-hoc-T-SQL gegen Delta-Tabellen im Lakehouse auszuführen?'),
      [
        o('A', 'SQL analytics endpoint', 'SQL-Analyseendpunkt'),
        o('B', 'Data Activator', 'Data Activator'),
        o('C', 'Domain assignment', 'Domänenzuweisung'),
        o('D', 'RLS editor', 'RLS-Editor')
      ],
      ['A'],
      t('The SQL analytics endpoint provides a read-only SQL surface over lakehouse Delta tables for analysts who prefer T-SQL.', 'Der SQL-Analyseendpunkt stellt eine schreibgeschützte SQL-Oberfläche über Delta-Tabellen im Lakehouse für Analysten bereit, die T-SQL bevorzugen.'),
      t('This is the SQL surface on top of the lakehouse.', 'Dies ist die SQL-Oberfläche auf dem Lakehouse.'),
      ref.lakehouse),

    q('dp700-363', 'single', explore, 'medium', null,
      t('Which Fabric item is designed for authoring and saving KQL queries for real-time analytics investigations?', 'Welches Fabric-Element ist zum Erstellen und Speichern von KQL-Abfragen für Echtzeitanalyse-Untersuchungen vorgesehen?'),
      [
        o('A', 'KQL Queryset', 'KQL-Queryset'),
        o('B', 'Deployment pipeline', 'Deployment-Pipeline'),
        o('C', 'Dataflow Gen2', 'Dataflow Gen2'),
        o('D', 'Paginated report dataset', 'Dataset für paginierte Berichte')
      ],
      ['A'],
      t('A KQL Queryset is the workspace experience for authoring, organizing, and reusing KQL queries over real-time analytics data.', 'Ein KQL-Queryset ist die Arbeitsbereichserfahrung zum Erstellen, Organisieren und Wiederverwenden von KQL-Abfragen über Echtzeitanalysedaten.'),
      t('Choose the KQL authoring surface.', 'Wählen Sie die Oberfläche zum Erstellen von KQL.'),
      ref.queryset),

    q('dp700-364', 'single', explore, 'medium',
      t('You run this KQL query:\n\nEvents\n| summarize Count = count() by DeviceId', 'Sie führen diese KQL-Abfrage aus:\n\nEvents\n| summarize Count = count() by DeviceId'),
      t('What does the result show?', 'Was zeigt das Ergebnis?'),
      [
        o('A', 'One row per DeviceId with the number of events for that device', 'Eine Zeile pro DeviceId mit der Anzahl der Ereignisse für dieses Gerät'),
        o('B', 'Only the latest event record', 'Nur den neuesten Ereignisdatensatz'),
        o('C', 'A list of workspace roles by device', 'Eine Liste der Arbeitsbereichsrollen pro Gerät'),
        o('D', 'A DAX measure definition', 'Eine DAX-Measure-Definition')
      ],
      ['A'],
      t('summarize ... by DeviceId groups the data by device and calculates the event count for each group.', 'summarize ... by DeviceId gruppiert die Daten nach Gerät und berechnet die Ereignisanzahl für jede Gruppe.'),
      t('Focus on summarize and the grouping key.', 'Achten Sie auf summarize und den Gruppierungsschlüssel.'),
      ref.kql),

    q('dp700-365', 'single', explore, 'medium',
      t('Users want to right-click a value in a summary report and open a detailed page filtered to that selected context.', 'Benutzer möchten mit der rechten Maustaste auf einen Wert in einem Übersichtsbericht klicken und eine Detailseite öffnen, die auf den ausgewählten Kontext gefiltert ist.'),
      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', 'OLS', 'OLS'),
        o('D', 'Mirroring', 'Mirroring')
      ],
      ['A'],
      t('Drillthrough is built for navigating from a summarized report context to a detail page filtered by the selected value or values.', 'Drillthrough ist dafür vorgesehen, von einem zusammengefassten Berichtskontext zu einer Detailseite zu navigieren, die nach den ausgewählten Werten gefiltert ist.'),
      t('Navigate from summary to detail.', 'Navigieren Sie von der Zusammenfassung ins Detail.'),
      ref.drillthrough),

    q('dp700-366', 'single', explore, 'hard',
      t('Finance needs monthly statements with a precise printable layout, report parameters, and scheduled email delivery.', 'Der Finanzbereich benötigt monatliche Auszüge mit präzisem druckbarem Layout, Berichtsparametern und geplanter E-Mail-Zustellung.'),
      t('Which reporting solution is best?', 'Welche Berichtslösung ist am besten?'),
      [
        o('A', 'Paginated report with subscriptions', 'Paginierter Bericht mit Abonnements'),
        o('B', 'KQL dashboard', 'KQL-Dashboard'),
        o('C', 'Notebook output cell', 'Notebook-Ausgabezelle'),
        o('D', 'Bookmark-only report', 'Bericht nur mit Lesezeichen')
      ],
      ['A'],
      t('Paginated reports are designed for exact layout, parameterized execution, and scheduled distribution, which makes them ideal for statements and invoices.', 'Paginierte Berichte sind für exaktes Layout, parametrisierte Ausführung und geplante Verteilung ausgelegt und daher ideal für Auszüge und Rechnungen.'),
      t('Print layout plus delivery points to paginated reports.', 'Drucklayout plus Zustellung weist auf paginierte Berichte hin.'),
      ref.paginated),

    q('dp700-367', 'single', explore, 'medium', null,
      t('Which Fabric capability monitors data and can trigger notifications or actions when a condition is met?', 'Welche Fabric-Funktion überwacht Daten und kann Benachrichtigungen oder Aktionen auslösen, wenn eine Bedingung erfüllt ist?'),
      [
        o('A', 'Data Activator', 'Data Activator'),
        o('B', 'Deployment pipeline', 'Deployment-Pipeline'),
        o('C', 'Warehouse clone', 'Warehouse-Klon'),
        o('D', 'Workspace domain', 'Arbeitsbereichsdomäne')
      ],
      ['A'],
      t('Data Activator is intended for event-driven monitoring and response. It can watch metrics or events and trigger alerts or workflows when thresholds are crossed.', 'Data Activator ist für ereignisgesteuerte Überwachung und Reaktion gedacht. Er kann Kennzahlen oder Ereignisse überwachen und Warnungen oder Workflows auslösen, wenn Schwellenwerte überschritten werden.'),
      t('Think alerting from data conditions.', 'Denken Sie an Alarmierung auf Basis von Datenbedingungen.'),
      ref.activator),

    q('dp700-368', 'multiple', explore, 'medium', null,
      t('Which two capabilities are typical reasons to use notebooks during analysis in Fabric?', 'Welche zwei Fähigkeiten sind typische Gründe, Notebooks während der Analyse in Fabric zu verwenden?'),
      [
        o('A', 'Run Python or Spark code interactively', 'Python- oder Spark-Code interaktiv ausführen'),
        o('B', 'Visualize intermediate results inline', 'Zwischenergebnisse direkt inline visualisieren'),
        o('C', 'Assign tenant-wide admin settings', 'Mandantenweite Admin-Einstellungen zuweisen'),
        o('D', 'Replace RLS configuration in semantic models', 'RLS-Konfiguration in semantischen Modellen ersetzen')
      ],
      ['A', 'B'],
      t('Notebooks support interactive code execution and inline inspection of results, which makes them ideal for exploratory and engineering workflows.', 'Notebooks unterstützen interaktive Codeausführung und die direkte Prüfung von Ergebnissen, was sie ideal für explorative und technische Workflows macht.'),
      t('Choose the answers related to interactive analysis.', 'Wählen Sie die Antworten, die sich auf interaktive Analyse beziehen.'),
      ref.notebook),

    q('dp700-369', 'single', explore, 'medium',
      t('An operations center wants a dashboard optimized for real-time telemetry and KQL-backed visuals.', 'Ein Operations Center möchte ein Dashboard, das für Echtzeit-Telemetrie und KQL-basierte Visuals optimiert ist.'),
      t('Which experience is the best fit?', 'Welche Erfahrung passt am besten?'),
      [
        o('A', 'Real-time dashboard', 'Echtzeit-Dashboard'),
        o('B', 'Paginated report', 'Paginierter Bericht'),
        o('C', 'Deployment pipeline', 'Deployment-Pipeline'),
        o('D', 'Workspace role page', 'Seite für Arbeitsbereichsrollen')
      ],
      ['A'],
      t('Real-time dashboards in Fabric are designed for operational monitoring over real-time analytics data and KQL-driven insights.', 'Echtzeit-Dashboards in Fabric sind für operative Überwachung über Echtzeitanalysedaten und KQL-gesteuerte Erkenntnisse ausgelegt.'),
      t('This is an operational monitoring scenario.', 'Dies ist ein Szenario für operative Überwachung.'),
      ref.dashboard),

    q('dp700-370', 'single', explore, 'easy', null,
      t('Which Power BI feature lets business users ask natural-language questions over a semantic model?', 'Welche Power-BI-Funktion ermöglicht es Fachanwendern, natürliche Sprachfragen über ein semantisches Modell zu stellen?'),
      [
        o('A', 'Q&A', 'Q&A'),
        o('B', 'OLS', 'OLS'),
        o('C', 'Shortcut', 'Shortcut'),
        o('D', 'Mirroring', 'Mirroring')
      ],
      ['A'],
      t('Q&A provides a natural-language experience for exploring semantic-model data without writing DAX or SQL.', 'Q&A bietet eine natürliche Sprachoberfläche, um Daten aus semantischen Modellen zu erkunden, ohne DAX oder SQL zu schreiben.'),
      t('The clue is natural-language questions.', 'Der Hinweis sind Fragen in natürlicher Sprache.'),
      ref.qa)
  ];

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