Importieren von Dateien aus SharePoint

Von Bedeutung

Der SharePoint-Standardconnector befindet sich in der Betaversion. Arbeitsbereichsadministratoren können den Zugriff auf dieses Feature über die Vorschauseite steuern. Siehe Verwalten von Azure Databricks-Vorschauen.

Erfahren Sie, wie Sie strukturierte, halbstrukturierte und unstrukturierte Dateien aus Microsoft SharePoint in Delta-Tabellen aufnehmen. Der SharePoint-Connector unterstützt die inkrementelle Erfassung von SharePoint-Dateien mithilfe von Batch- und Streaming-APIs, einschließlich Auto Loader spark.read und COPY INTO, alles mit Unity Catalog Governance.

Auswählen Ihres SharePoint-Connectors

Lakeflow Connect bietet zwei ergänzende SharePoint-Connectors. Beide greifen in SharePoint auf Daten zu, unterstützen jedoch unterschiedliche Ziele.

Überlegung	Verwalteter SharePoint-Connector	Standard-SharePoint-Connector
Verwaltung und Anpassung	Ein vollständig verwalteter Steckverbinder. Einfache, wartungsarme Connectors für Unternehmensanwendungen, die Daten in Delta-Tabellen aufnehmen und mit der Quelle synchronisieren. Siehe Managed Connectors in Lakeflow Connect.	Erstellen Sie benutzerdefinierte Aufnahmepipelines mit SQL, PySpark oder Lakeflow Spark Declarative Pipelines mithilfe von Batch- und Streaming-APIs wie `read_files`, `spark.read`, `COPY INTO` und Auto Loader. Bietet die Flexibilität, komplexe Transformationen während der Aufnahme durchzuführen, und bietet Ihnen eine größere Verantwortung für die Verwaltung und Wartung Ihrer Pipelines.
Ausgabeformat	Einheitliche Binärinhaltstabelle. Verarbeitet jede Datei im Binärformat (eine Datei pro Zeile) zusammen mit den Dateimetadaten. zusätzliche Spalten.	Strukturierte Delta-Tabellen. Nimmt strukturierte Dateien (z. B. CSV und Excel) als Delta-Tabellen ein. Kann auch zum Aufnehmen verwendet werden unstrukturierte Dateien im Binärformat.
Granularität, Filterung und Auswahl	Heute gibt es keine Auswahl auf Unterordner- oder Dateiebene. Keine musterbasierte Filterung. Nimmt alle Dateien in der angegebenen SharePoint-Dokumentbibliothek ein.	Granular und benutzerdefiniert. URL-basierte Auswahl, die aus Dokumentbibliotheken, Unterordnern oder einzelnen Dateien aufgenommen werden soll. Unterstützt auch die Filterung basierend auf Mustern mithilfe der `pathGlobFilter` Option.

Wichtigste Funktionen

Der Standardmäßige SharePoint-Connector bietet:

Erfassung strukturierter, halbstrukturierter und unstrukturierter Dateien
Granularer Erfassungsvorgang: Erfassen einer spezifischen Website, einer Unterwebsite, einer Dokumentenbibliothek, eines Ordners oder einer einzelnen Datei
Batch- und Streamingaufnahme mit spark.read, Auto Loader und COPY INTO
Automatische Schema-Ableitung und Weiterentwicklung für strukturierte und halbstrukturierte Formate wie CSV und Excel
Sichere Aufbewahrung von Anmeldeinformationen mit einer Unity Catalog-Verbindung
Dateiauswahl mit Musterabgleich mit pathGlobFilter

Anforderungen

Zum Aufnehmen von Dateien aus SharePoint benötigen Sie Folgendes:

Ein Arbeitsbereich mit aktiviertem Unity-Katalog
CREATE CONNECTION Berechtigungen zum Erstellen einer SharePoint-Verbindung (oder USE CONNECTION zum Verwenden einer vorhandenen)
Berechnungen, die die Databricks Runtime Version 17.3 LTS oder höher verwenden
OAuth-Authentifizierung ist mit dem Berechtigungsbereich Sites.Read.All eingerichtet worden.
Das SharePoint Beta-Feature ist über die Vorschauseite aktiviert. Siehe Verwalten von Azure Databricks-Vorschauen
Optional: Aktivieren Sie das Excel Beta-Feature zum Analysieren von Excel-Dateien. Siehe Excel-Dateien lesen

Erstellen der Verbindung

Erstellen Sie eine Unity-Katalogverbindung, um Ihre SharePoint-Anmeldeinformationen zu speichern. Der Verbindungseinrichtungsprozess wird sowohl zwischen den Standard- als auch zwischen verwalteten SharePoint-Connectors gemeinsam genutzt.

Vollständige Anweisungen zum Einrichten der Verbindung, einschließlich OAuth-Authentifizierungsoptionen, finden Sie unter Übersicht über das Einrichten von SharePoint-Erfassungen.

Lesen von Dateien aus SharePoint

Wenn Sie Dateien aus SharePoint mithilfe von Spark lesen möchten, geben Sie die Verbindung an, die Sie im vorherigen Schritt mithilfe der databricks.connection Datenquellenoption erstellt haben, und geben Sie die URL der SharePoint-Ressource an, auf die Sie zugreifen möchten. Diese URL kann auf eine bestimmte Datei, einen Ordner, eine Dokumentbibliothek (Laufwerk) oder eine gesamte Website verweisen. Beispiele sind:

https://mytenant.sharepoint.com/sites/test-site/
https://mytenant.sharepoint.com/sites/test-site/test-subsite
https://mytenant.sharepoint.com/sites/test-site/test-drive
https://mytenant.sharepoint.com/sites/test-site/Shared%20Documents/Forms/AllItems.aspx
https://mytenant.sharepoint.com/sites/test-site/test-drive/test-folder
https://mytenant.sharepoint.com/sites/test-site/test-drive/test-folder/test.csv
https://mytenant.sharepoint.com/sites/test-site/another-subsite/another-drive/test.csv

Examples

Hier finden Sie Codebeispiele zum Lesen von Dateien mithilfe des Standardmäßigen SharePoint-Connectors.

Streamen von SharePoint-Dateien mit automatischem Ladeprogramm

Auto Loader bietet die effizienteste Möglichkeit, strukturierte Dateien in SharePoint inkrementell aufzunehmen. Es erkennt automatisch neue Dateien und verarbeitet sie beim Eintreffen. Sie kann auch strukturierte und halbstrukturierte Dateien wie CSV und JSON mit automatischer Schemaschlussfolgerung und -entwicklung aufnehmen. Ausführliche Informationen zur Verwendung des automatischen Ladevorgangs finden Sie unter Allgemeine Datenlademuster.

# Incrementally ingest new PDF files
df = (spark.readStream.format("cloudFiles")
    .option("cloudFiles.format", "binaryFile")
    .option("databricks.connection", "my_sharepoint_conn")
    .option("cloudFiles.schemaLocation", <path to a schema location>)
    .option("pathGlobFilter", "*.pdf")
    .load("https://mytenant.sharepoint.com/sites/Marketing/Shared%20Documents")
)

# Incrementally ingest CSV files with automatic schema inference and evolution
df = (spark.readStream.format("cloudFiles")
    .option("cloudFiles.format", "csv")
    .option("databricks.connection", "my_sharepoint_conn")
    .option("pathGlobFilter", "*.csv")
    .option("inferColumnTypes", True)
    .option("header", True)
    .load("https://mytenant.sharepoint.com/sites/Engineering/Data/IoT_Logs")
)

Lesen von SharePoint-Dateien mit Spark-Batchlesevorgang

# Read unstructured data as binary files
df = (spark.read
        .format("binaryFile")
        .option("databricks.connection", "my_sharepoint_conn")
        .option("recursiveFileLookup", True)
        .option("pathGlobFilter", "*.pdf") # optional. Example: only ingest PDFs
        .load("https://mytenant.sharepoint.com/sites/Marketing/Shared%20Documents"))

# Read a batch of CSV files, infer the schema, and load the data into a DataFrame
df = (spark.read
        .format("csv")
        .option("databricks.connection", "my_sharepoint_conn")
        .option("pathGlobFilter", "*.csv")
        .option("recursiveFileLookup", True)
        .option("inferSchema", True)
        .option("header", True)
        .load("https://mytenant.sharepoint.com/sites/Engineering/Data/IoT_Logs"))

# Read a specific Excel file from SharePoint, infer the schema, and load the data into a DataFrame
df = (spark.read
        .format("excel")
        .option("databricks.connection", "my_sharepoint_conn")
        .option("headerRows", 1)                   # optional
        .option("dataAddress", "'Sheet1'!A1:M20")  # optional
        .load("https://mytenant.sharepoint.com/sites/Finance/Shared%20Documents/Monthly/Report-Oct.xlsx"))

Lesen von SharePoint-Dateien mit Spark SQL

Das folgende Beispiel zeigt, wie Sie SharePoint-Dateien in SQL mithilfe von read_files Tabellenwertfunktion aufnehmen. Ausführliche Informationen zur read_files Verwendung finden Sie in read_files der Tabellenwertfunktion.

-- Read pdf files
CREATE TABLE my_table AS
SELECT * FROM read_files(
  "https://mytenant.sharepoint.com/sites/Marketing/Shared%20Documents",
  `databricks.connection` => "my_sharepoint_conn",
  format => "binaryFile",
  pathGlobFilter => "*.pdf", -- optional. Example: only ingest PDFs
  schemaEvolutionMode => "none"
);

-- Read a specific Excel sheet and range
CREATE TABLE my_sheet_table AS
SELECT * FROM read_files(
  "https://mytenant.sharepoint.com/sites/Finance/Shared%20Documents/Monthly/Report-Oct.xlsx",
  `databricks.connection` => "my_sharepoint_conn",
  format => "excel",
  headerRows => 1,  -- optional
  dataAddress => "'Sheet1'!A2:D10", -- optional
  schemaEvolutionMode => "none"
);

Inkrementelle Aufnahme mit `COPY INTO`

COPY INTO ermöglicht das idempotente inkrementelle Laden von Dateien in eine Delta-Tabelle. Ausführliche Informationen zur COPY INTO Verwendung finden Sie unter Allgemeine Datenlademuster mithilfe von COPY INTO.

CREATE TABLE IF NOT EXISTS sharepoint_pdf_table;
CREATE TABLE IF NOT EXISTS sharepoint_csv_table;
CREATE TABLE IF NOT EXISTS sharepoint_excel_table;

# Incrementally ingest new PDF files
COPY INTO sharepoint_pdf_table
  FROM "https://mytenant.sharepoint.com/sites/Marketing/Shared%20Documents"
  FILEFORMAT = BINARYFILE
  PATTERN = '*.pdf'
  FORMAT_OPTIONS ('databricks.connection' = 'my_sharepoint_conn')
  COPY_OPTIONS ('mergeSchema' = 'true');

# Incrementally ingest CSV files with automatic schema inference and evolution
COPY INTO sharepoint_csv_table
  FROM "https://mytenant.sharepoint.com/sites/Engineering/Data/IoT_Logs"
  FILEFORMAT = CSV
  PATTERN = '*.csv'
  FORMAT_OPTIONS ('databricks.connection' = 'my_sharepoint_conn', 'header' = 'true', 'inferSchema' = 'true')
  COPY_OPTIONS ('mergeSchema' = 'true');

# Ingest a single Excel file
COPY INTO sharepoint_excel_table
  FROM "https://mytenant.sharepoint.com/sites/Finance/Shared%20Documents/Monthly/Report-Oct.xlsx"
  FILEFORMAT = EXCEL
  FORMAT_OPTIONS ('databricks.connection' = 'my_sharepoint_conn', 'headerRows' = '1')
  COPY_OPTIONS ('mergeSchema' = 'true');

Aufnahme von SharePoint-Dateien in Lakeflow Spark Declarative Pipelines

Hinweis

SharePoint Connector erfordert Databricks Runtime 17.3 oder höher. Dies ist in Lakeflow Spark Declarative Pipelines release noch nicht verfügbar. Die Databricks-Runtime-Versionen, die mit einer Lakeflow Spark Declarative Pipelines-Version verwendet werden, finden Sie in den Versionshinweisen zu dieser Version.

Die folgenden Beispiele zeigen, wie Sie SharePoint-Dateien mit auto Loader in Lakeflow Spark Declarative Pipelines lesen:

Python

from pyspark import pipelines as dp

# Incrementally ingest new PDF files
@dp.table
def sharepoint_pdf_table():
  return (spark.readStream.format("cloudFiles")
    .option("cloudFiles.format", "binaryFile")
    .option("databricks.connection", "my_sharepoint_conn")
    .option("pathGlobFilter", "*.pdf")
    .load("https://mytenant.sharepoint.com/sites/Marketing/Shared%20Documents")
  )

# Incrementally ingest CSV files with automatic schema inference and evolution
@dp.table
def sharepoint_csv_table():
  return (spark.readStream.format("cloudFiles")
      .option("cloudFiles.format", "csv")
      .option("databricks.connection", "my_sharepoint_conn")
      .option("pathGlobFilter", "*.csv")
      .option("inferColumnTypes", True)
      .option("header", True)
      .load("https://mytenant.sharepoint.com/sites/Engineering/Data/IoT_Logs")
  )

# Read a specific Excel file from SharePoint in a materialized view
@dp.table
def sharepoint_excel_table():
  return (spark.read.format("excel")
    .option("databricks.connection", "my_sharepoint_conn")
    .option("headerRows", 1)                   # optional
    .option("inferColumnTypes", True)            # optional
    .option("dataAddress", "'Sheet1'!A1:M20")  # optional
    .load("https://mytenant.sharepoint.com/sites/Finance/Shared%20Documents/Monthly/Report-Oct.xlsx")

SQL

-- Incrementally ingest new PDF files
CREATE OR REFRESH STREAMING TABLE sharepoint_pdf_table
AS SELECT * FROM STREAM read_files(
  "https://mytenant.sharepoint.com/sites/Marketing/Shared%20Documents",
  format => "binaryFile",
  `databricks.connection` => "my_sharepoint_conn",
  pathGlobFilter => "*.pdf");

-- Incrementally ingest CSV files with automatic schema inference and evolution
CREATE OR REFRESH STREAMING TABLE sharepoint_csv_table
AS SELECT * FROM STREAM read_files(
  "https://mytenant.sharepoint.com/sites/Engineering/Data/IoT_Logs",
  format => "csv",
  `databricks.connection` => "my_sharepoint_conn",
  pathGlobFilter => "*.csv",
  "header", "true");

-- Read a specific Excel file from SharePoint in a materialized view
CREATE OR REFRESH MATERIALIZED VIEW sharepoint_excel_table
AS SELECT * FROM read_files(
  "https://mytenant.sharepoint.com/sites/Finance/Shared%20Documents/Monthly/Report-Oct.xlsx",
  `databricks.connection` => "my_sharepoint_conn",
  format => "excel",
  headerRows => 1,  -- optional
  dataAddress => "'Sheet1'!A2:D10", -- optional
  `cloudFiles.schemaEvolutionMode` => "none"
);

Analysieren unstrukturierter Dateien

Beim Aufnehmen unstrukturierter Dateien aus SharePoint (z. B. PDFs, Word-Dokumente oder PowerPoint-Dateien) mithilfe des Standardmäßigen SharePoint-Connectors mit binaryFile Format werden die Dateiinhalte als unformatierte Binärdaten gespeichert. Um diese Dateien für KI-Workloads wie RAG, Suche, Klassifizierung oder Dokumentverständnis vorzubereiten, können Sie den binären Inhalt mithilfe von ai_parse_documentstrukturierten, abfragbaren Ausgaben analysieren.

Das folgende Beispiel zeigt, wie unstrukturierte Dokumente analysiert werden, die in einer bronzenen Delta-Tabelle mit dem Namen documents"Hinzufügen einer neuen Spalte mit analysiertem Inhalt" gespeichert sind:

CREATE TABLE documents AS
SELECT * FROM read_files(
  "https://mytenant.sharepoint.com/sites/Marketing/Shared%20Documents",
  `databricks.connection` => "my_sharepoint_conn",
  format => "binaryFile",
  pathGlobFilter => "*.pdf,*.docx",
  schemaEvolutionMode => "none"
);
SELECT *, ai_parse_document(content) AS parsed_content
FROM documents;

Die parsed_content Spalte enthält extrahierten Text, Tabellen, Layoutinformationen und Metadaten, die direkt für nachgeschaltete KI-Pipelines verwendet werden können.

Inkrementelle Analyse mit Lakeflow Spark Declarative Pipelines

Sie können ai_parse_document auch innerhalb von Lakeflow Spark Declarative Pipelines verwenden, um die inkrementelle Analyse zu ermöglichen. Wenn neue Dateien aus SharePoint übertragen werden, werden sie automatisch als Pipelineupdates analysiert.

Sie können beispielsweise eine materialisierte Ansicht definieren, die ständig neu aufgenommene Dokumente analysiert:

CREATE OR REFRESH STREAMING TABLE sharepoint_documents_table
AS SELECT * FROM STREAM read_files(
  "https://mytenant.sharepoint.com/sites/Marketing/Shared%20Documents",
  format => "binaryFile",
  `databricks.connection` => "my_sharepoint_conn",
  pathGlobFilter => "*.pdf,*.docx");

CREATE OR REFRESH MATERIALIZED VIEW documents_parsed
AS
SELECT *, ai_parse_document(content) AS parsed_content
FROM sharepoint_documents_table;

Mit diesem Ansatz wird Folgendes sichergestellt:

Neu aufgenommene SharePoint-Dateien werden automatisch analysiert, wenn die materialisierte Ansicht aktualisiert wird.
Analysierte Ausgaben bleiben mit eingehenden Daten synchronisiert
Nachgeschaltete KI-Pipelines arbeiten immer mit up-to-Date-Dokumentdarstellungen

Weitere Informationen finden Sie in ai_parse_document zu unterstützten Formaten und erweiterten Optionen.

Einschränkungen

Der Standardmäßige SharePoint-Connector hat die folgenden Einschränkungen:

Keine Aufnahme mehrerer Websites: Sie können nicht mehrere Websites mit derselben Abfrage aufnehmen. Um Daten von zwei Standorten einzulesen, müssen Sie zwei separate Abfragen schreiben.
Filterung: Sie können die pathGlobFilter Option verwenden, um Dateien nach Namen zu filtern. Die pfadbasierte Ordnerfilterung wird nicht unterstützt.
Nicht unterstützte Formate: SharePoint-Listen und .aspx Websiteseiten werden nicht unterstützt. Nur Dateien in Dokumentbibliotheken werden unterstützt.
Das Zurückschreiben auf einen SharePoint-Server wird nicht unterstützt.
Das Element "Auto Loader" cleanSource (Löschen oder Archivieren von Dateien an der Quelle nach der Einspeisung) wird nicht unterstützt.

Nächste Schritte

Informationen zu Auto Loader für fortschrittliche Streaming-Ingestion-Patterns
Untersuchen COPY INTO für idempotente inkrementelle Ladevorgänge
Vergleich mit Cloudobjektspeicher-Erfassungsmustern
Richten Sie das Job-Scheduling ein, um Ihre Erfassungsworkflows zu automatisieren.
Verwenden von Lakeflow Spark Declarative Pipelines zum Erstellen von End-to-End-Datenpipelines mit Transformationen

Feedback

War diese Seite hilfreich?

Last updated on 2025-12-19