Freigeben über

Gewusst wie: Speichern von Daten in OneLake

Jedes Fabric-Element hat Zugriff auf OneLake-Speicher, der eine sichere, skalierbare Möglichkeit zum Speichern von Dateien bietet, die Ihrem Element zugeordnet sind. In diesem Handbuch wird erläutert, wie Sie Dateien mithilfe der zugrunde liegenden FabricPlatformAPIClient- und OneLakeClient-Elemente auf Ihr Fabric-Element hochladen.

Verständnis der Speicherung von Items in Fabric

Jedes Element in Fabric verfügt über einen eigenen dedizierten Speicherbereich in OneLake. Dieser Speicher ist in Ordnern organisiert, wobei die hauptordner sind:

  • Dateien – Zum Speichern allgemeiner Dateien und Dokumente
  • Tabellen – Zum Speichern von Tabellendaten

Voraussetzungen

Bevor Sie Dateien in Ihr Element hochladen, benötigen Sie Folgendes:

  • Ein gültiger Fabric-Arbeitsbereich
  • Ein vorhandenes Element, in das Sie die Datei hochladen möchten
  • Geeignete Berechtigungen zum Schreiben in das Element

Erstellen des FabricPlatformAPIClient

Erstellen Sie zunächst eine FabricPlatformAPIClient Instanz:

import { getWorkloadClient } from "../controller/WorkloadClient";
import { FabricPlatformAPIClient } from "../clients/FabricPlatformAPIClient";

// Create client using the current user's context
const fabricClient = FabricPlatformAPIClient.create(getWorkloadClient());

Beispiel: Hochladen einer Textdatei in ein Element

Hier erfahren Sie, wie Sie eine Textdatei mithilfe des OneLake-Clients in ein Element hochladen:

async function uploadTextFileToItem(
  workspaceId: string, 
  itemId: string, 
  fileName: string, 
  content: string
) {
  try {
    // Get the FabricPlatformAPIClient
    const fabricClient = FabricPlatformAPIClient.create(getWorkloadClient());
    
    // Access the OneLake client
    const oneLakeClient = fabricClient.oneLake;
    
    // Generate the file path in OneLake for this item
    // This follows the pattern: workspaceId/itemId/Files/fileName
    const filePath = oneLakeClient.constructor.getFilePath(workspaceId, itemId, fileName);
    
    // Write the text content to the file
    await oneLakeClient.writeFileAsText(filePath, content);
    
    console.log(`Successfully uploaded ${fileName} to item ${itemId}`);
    return true;
  } catch (error) {
    console.error("Error uploading file to item:", error);
    throw error;
  }
}

Beispiel: Hochladen einer Binärdatei in ein Element

Bei Binärdateien wie Bildern oder PDF-Dateien müssen Sie die Datei zuerst in Base64 konvertieren:

async function uploadBinaryFileToItem(
  workspaceId: string,
  itemId: string,
  fileName: string,
  fileData: ArrayBuffer // Binary file data
) {
  try {
    const fabricClient = FabricPlatformAPIClient.create(getWorkloadClient());
    const oneLakeClient = fabricClient.oneLake;
    
    // Convert binary data to base64
    const base64Content = arrayBufferToBase64(fileData);
    
    // Generate the file path
    const filePath = oneLakeClient.constructor.getFilePath(workspaceId, itemId, fileName);
    
    // Write the binary content to the file
    await oneLakeClient.writeFileAsBase64(filePath, base64Content);
    
    console.log(`Successfully uploaded binary file ${fileName} to item ${itemId}`);
    return true;
  } catch (error) {
    console.error("Error uploading binary file to item:", error);
    throw error;
  }
}

// Helper function to convert ArrayBuffer to base64
function arrayBufferToBase64(buffer: ArrayBuffer): string {
  let binary = '';
  const bytes = new Uint8Array(buffer);
  const len = bytes.byteLength;
  
  for (let i = 0; i < len; i++) {
    binary += String.fromCharCode(bytes[i]);
  }
  
  return btoa(binary);
}

Beispiel: Hochladen einer Datei aus dem Browser

Wenn Sie eine Webschnittstelle erstellen, können Sie diese Funktion verwenden, um Dateiuploads aus einer Dateieingabe zu behandeln:

async function handleFileUpload(
  workspaceId: string,
  itemId: string,
  fileInputElement: HTMLInputElement
) {
  if (!fileInputElement.files || fileInputElement.files.length === 0) {
    console.warn("No file selected");
    return false;
  }
  
  const file = fileInputElement.files[0];
  const fileName = file.name;
  
  try {
    // Read the file as ArrayBuffer
    const fileBuffer = await readFileAsArrayBuffer(file);
    
    // Upload based on file type
    if (file.type.startsWith('text/')) {
      // For text files, convert to string and upload as text
      const textDecoder = new TextDecoder();
      const textContent = textDecoder.decode(fileBuffer);
      
      return await uploadTextFileToItem(workspaceId, itemId, fileName, textContent);
    } else {
      // For binary files, upload as base64
      return await uploadBinaryFileToItem(workspaceId, itemId, fileName, fileBuffer);
    }
  } catch (error) {
    console.error("Error processing file upload:", error);
    throw error;
  }
}

// Helper function to read file as ArrayBuffer
function readFileAsArrayBuffer(file: File): Promise<ArrayBuffer> {
  return new Promise((resolve, reject) => {
    const reader = new FileReader();
    reader.onload = () => resolve(reader.result as ArrayBuffer);
    reader.onerror = reject;
    reader.readAsArrayBuffer(file);
  });
}

Verwalten von Dateien in Ihrem Element

Sobald Dateien hochgeladen wurden, können Sie auch:

Überprüfen, ob eine Datei vorhanden ist

async function checkFileExists(workspaceId: string, itemId: string, fileName: string) {
  const fabricClient = FabricPlatformAPIClient.create(getWorkloadClient());
  const filePath = fabricClient.oneLake.constructor.getFilePath(workspaceId, itemId, fileName);
  
  return await fabricClient.oneLake.checkIfFileExists(filePath);
}

Dateiinhalt lesen

async function readTextFile(workspaceId: string, itemId: string, fileName: string) {
  const fabricClient = FabricPlatformAPIClient.create(getWorkloadClient());
  const filePath = fabricClient.oneLake.constructor.getFilePath(workspaceId, itemId, fileName);
  
  return await fabricClient.oneLake.readFileAsText(filePath);
}

Löschen einer Datei

async function deleteFile(workspaceId: string, itemId: string, fileName: string) {
  const fabricClient = FabricPlatformAPIClient.create(getWorkloadClient());
  const filePath = fabricClient.oneLake.constructor.getFilePath(workspaceId, itemId, fileName);
  
  await fabricClient.oneLake.deleteFile(filePath);
  console.log(`File ${fileName} deleted successfully`);
}

Bewährte Methoden für Dateiuploads

  • Verwenden Sie geeignete Dateiformate: Berücksichtigen Sie den Zweck der Datei und verwenden Sie Formate, die weit verbreitet werden.
  • Behandeln Sie Fehler ordnungsgemäß: Schließen Sie immer die Fehlerbehandlung für Netzwerkprobleme oder Berechtigungsprobleme ein.
  • Überprüfen von Dateigrößen: Große Dateien können länger dauern, um sie hochzuladen und zu verarbeiten.
  • Überprüfen Sie die Berechtigungen: Stellen Sie sicher, dass der Benutzer über entsprechende Berechtigungen verfügt, bevor Sie uploads versuchen.
  • Verwenden Sie Dateipräfixe oder Ordner: Bei komplexen Elementen mit vielen Dateien sollten Sie sie in Unterordnern organisieren.

Verwenden des OneLakeClientItemWrapper

Für den vereinfachten Zugriff auf Elementdateien können Sie folgendes OneLakeClientItemWrapperverwenden:

async function uploadFileWithItemWrapper(item, fileName, content) {
  const fabricClient = FabricPlatformAPIClient.create(getWorkloadClient());
  
  // Create a wrapper for simpler access to this specific item
  const itemWrapper = fabricClient.oneLake.createItemWrapper({
    workspaceId: item.workspaceId,
    itemId: item.id
  });
  
  // Upload directly to the item (no need to specify paths)
  await itemWrapper.writeFileAsText(fileName, content);
  
  // Read the file back
  const fileContent = await itemWrapper.readFileAsText(fileName);
  
  console.log(`File uploaded and read back: ${fileContent.substring(0, 50)}...`);
}

Dieser Wrapper vereinfacht Dateivorgänge, indem die vollständige Pfaderstellung automatisch verarbeitet wird.

  • Last updated on