Microsoft JDBC-Treiber für Microsoft Fabric Data Engineering

JDBC (Java Database Connectivity) ist ein weit verbreiteter Standard, der es Clientanwendungen ermöglicht, eine Verbindung zu Datenbanken und Big-Data-Plattformen herzustellen und mit diesen zu arbeiten.

Der Microsoft JDBC Driver for Fabric Data Engineering ermöglicht es Ihnen, Spark-Workloads in Fabric mit der Zuverlässigkeit und Einfachheit des JDBC-Standards zu verbinden, abzufragen und zu verwalten. Basierend auf den Livy-APIs von Fabric bietet der Treiber eine sichere und flexible Spark-SQL-Konnektivität zu Ihren Java-Anwendungen und BI-Tools. Diese Integration ermöglicht es Ihnen, Spark-Code direkt einzureichen und auszuführen, ohne separate Notebook- oder Spark-Job-Definitionselemente erstellen zu müssen. Der Treiber ist mit beliebten JDBC-Clients wie DbVisualizer und DBeaver kompatibel sowie mit BI-Tools, die JDBC-Konnektivität unterstützen, einschließlich Tableau.

Wichtige Merkmale

JDBC 4.2 konform: Vollständige Implementierung der JDBC 4.2-Spezifikation
Microsoft Entra ID-Authentifizierung: Mehrere Authentifizierungsflüsse, einschließlich interaktiver, Clientanmeldeinformationen und zertifikatbasierter Authentifizierung
HikariCP-Integration: Verwenden Sie HikariCP, um JDBC-Verbindungen für Produktionsanwendungen zu verwalten und wiederzuverwenden
Spark SQL Native Query-Unterstützung: Direkte Ausführung von Spark SQL-Anweisungen ohne Übersetzung
Umfassende Unterstützung für Datentypen: Unterstützung für alle Spark SQL-Datentypen einschließlich komplexer Typen (ARRAY, MAP, STRUCT)
Asynchrones Ergebnismengen-Prefetching: Hintergrunddatenladen für verbesserte Leistung
Circuit Breaker Pattern: Schutz vor kaskadierenden Ausfällen mit automatischem Retry
Automatische Wiederverbindung: Transparente Sitzungswiederherstellung bei Verbindungsfehlern
Erweiterte Wiederholungslogik: Wiederholen mit exponentieller Backoff- und Sitzungswiederherstellung für verbesserte Resilienz
Proxyunterstützung: HTTP- und SOCKS-Proxykonfiguration für Unternehmensumgebungen

Voraussetzungen

Bevor Sie den Microsoft JDBC Driver für Fabric Data Engineering verwenden, stellen Sie sicher, dass Sie Folgendes haben:

Java Development Kit (JDK): Version 11 oder höher (Java 21 empfohlen)
Fabric Access: Zugang zu einem Fabric-Arbeitsbereich
Microsoft Entra ID-Anmeldeinformationen: Geeignete Anmeldeinformationen für die Authentifizierung
Arbeitsbereichs- und Lakehouse-IDs: GUID-IDs für den Fabric-Arbeitsbereich und das Lakehouse

Herunterladen und Installieren

Der Microsoft JDBC Driver for Fabric Data Engineering Version 1.0.0 unterstützt Java 11, 17 und 21. Wir verbessern kontinuierlich die Java-Konnektivitätsunterstützung und empfehlen Ihnen, mit der neuesten Version des Microsoft ASPX-Treibers zu arbeiten.

Laden Sie entweder die ZIP- oder Tar-Datei aus den obigen Links herunter.
Extrahieren Sie die heruntergeladene Datei, um auf die Treiber-JAR-Dateien zuzugreifen.
Wählen Sie die JAR-Datei aus, die Ihrer JRE-Version entspricht:
- Für Java 11: ms-sparksql-jdbc-1.0.1.jre11.jar
- Für Java 17: ms-sparksql-jdbc-1.0.1.jre17.jar
- Für Java 21: ms-sparksql-jdbc-1.0.1.jre21.jar
Fügen Sie die ausgewählte JAR-Datei zum Klassenpfad Ihrer Anwendung hinzu.
Konfigurieren Sie für JDBC-Clients die JDBC-Treiberklasse: com.microsoft.spark.livy.jdbc.LivyDriver

Schnellstartbeispiel

Dieses Beispiel zeigt, wie man sich mit Fabric verbindet und eine Abfrage mit dem Microsoft JDBC Driver for Fabric Data Engineering ausführen kann. Stellen Sie sicher, dass Sie die Voraussetzungen erfüllt und den Treiber installiert haben, bevor Sie diesen Code ausführen.

import java.sql.*;

public class QuickStartExample {
    public static void main(String[] args) {
        // Connection string with required parameters
        String url = "jdbc:fabricspark://api.fabric.microsoft.com;" +
                     "FabricWorkspaceID=<workspace-id>;" +
                     "FabricLakehouseID=<lakehouse-id>;" +
                     "AuthFlow=2;" +  // Azure CLI based authentication
                     "LogLevel=INFO";
        
        try (Connection conn = DriverManager.getConnection(url)) {
            // Execute a simple query
            try (Statement stmt = conn.createStatement();
                 ResultSet rs = stmt.executeQuery("SELECT 'Hello from Fabric!' as message")) {
                
                if (rs.next()) {
                    System.out.println(rs.getString("message"));
                }
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

Verbindungszeichenfolgenformat

Basisverbindungszeichenfolge

Der Microsoft JDBC Driver for Fabric Data Engineering verwendet folgendes Verbindungszeichenfolge-Format:

jdbc:fabricspark://<hostname>[:<port>][;<parameter1>=<value1>;<parameter2>=<value2>;...]

Verbindungskettenkomponenten

Komponente	Description	Example
Protokoll	JDBC-URL-Protokollkennzeichen	`jdbc:fabricspark://`
Hostname	Hostname des Fabric-Endpunkts	`api.fabric.microsoft.com`
Hafen	Optionale Portnummer (Standard: 443)	`:443`
Parameter	Durch Semikolons getrennte Schlüssel=Wert-Paare	`FabricWorkspaceID=<guid>`

Beispielverbindungszeichenfolgen

Standardverbindung (interaktive browserbasierte Authentifizierung)

jdbc:fabricspark://api.fabric.microsoft.com;FabricWorkspaceID=<workspace-id>;FabricLakehouseID=<lakehouse-id>;AuthFlow=1

Mit Spark-Ressourcenkonfiguration

jdbc:fabricspark://api.fabric.microsoft.com;FabricWorkspaceID=<workspace-id>;FabricLakehouseID=<lakehouse-id>;DriverCores=4;DriverMemory=4g;ExecutorCores=4;ExecutorMemory=8g;NumExecutors=2;AuthFlow=2

Mit Spark Session-Eigenschaften

jdbc:fabricspark://api.fabric.microsoft.com;FabricWorkspaceID=<workspace-id>;FabricLakehouseID=<lakehouse-id>;spark.sql.adaptive.enabled=true;spark.sql.shuffle.partitions=200;AuthFlow=2

Authentifizierung

Der Microsoft JDBC Driver for Fabric Data Engineering unterstützt mehrere Authentifizierungsmethoden über Microsoft Entra ID (früher Azure Active Directory). Die Authentifizierung wird mithilfe des AuthFlow Parameters in der Verbindungszeichenfolge konfiguriert.

Authentifizierungsabläufe

AuthFlow	Authentifizierungsmethode	Anwendungsfall
1	Interaktiver Browser	Interaktive Benutzerauthentifizierung mit OAuth 2.0
2	Azure-Befehlszeilenschnittstelle (Azure CLI)	Entwicklung mit Azure CLI
3	Geheime Clientschlüsselanmeldeinformationen (Dienstprinzipal)	Automatisierte/Dienst-zu-Dienst-Authentifizierung
4	Clientzertifikat-Anmeldeinformationen	Zertifikatbasierte Dienst-Principal-Authentifizierung
5	Zugriffstoken	Vorab erworbenes Bearerzugriffstoken

Interaktive Browserauthentifizierung

Am besten geeignet für: Entwicklung und interaktive Anwendungen

String url = "jdbc:fabricspark://api.fabric.microsoft.com;" +
             "FabricWorkspaceID=<workspace-id>;" +
             "FabricLakehouseID=<lakehouse-id>;" +
             "AuthFlow=1;" +  
             "AuthTenantID=<tenant-id>;" +  // Optional
             "LogLevel=INFO";

Connection conn = DriverManager.getConnection(url);

Parameter:

AuthFlow=1: Gibt die interaktive Browserauthentifizierung an.
AuthTenantID (optional): Microsoft Entra Mandanten-ID
AuthClientID (optional): Anwendungs-ID (Client)

Benehmen:

Öffnet ein Browserfenster für die Benutzerauthentifizierung.
Anmeldeinformationen werden für nachfolgende Verbindungen zwischengespeichert, bis sie abgelaufen sind.
Geeignet für Einzelbenutzeranwendungen

Client-Anmeldeinformationen oder Serviceprinzipal-Authentifizierung

Am besten geeignet für: Automatisierte Dienste und Hintergrundaufträge

String url = "jdbc:fabricspark://api.fabric.microsoft.com;" +
             "FabricWorkspaceID=<workspace-id>;" +
             "FabricLakehouseID=<lakehouse-id>;" +
             "AuthFlow=3;" +  
             "AuthClientID=<client-id>;" +
             "AuthClientSecret=<client-secret>;" +
             "AuthTenantID=<tenant-id>;" +
             "LogLevel=INFO";

Connection conn = DriverManager.getConnection(url);

Erforderliche Parameter:

AuthFlow=3: Gibt die Authentifizierung der Clientanmeldeinformationen an.
AuthClientID: Anwendungs-ID (Client-ID) von Microsoft Entra ID
AuthClientSecret: Geheimer Clientschlüssel von Microsoft Entra ID
AuthTenantID: Microsoft Entra Mandanten-ID

Bewährte Methoden:

Sicheres Speichern geheimer Schlüssel (Azure Key Vault, Umgebungsvariablen)
Verwenden von verwalteten Identitäten nach Möglichkeit
Regelmäßiges Erneuern von Geheimnissen

zertifikatbasierte Authentifizierung

Am besten geeignet für: Unternehmensanwendungen, die zertifikatbasierte Authentifizierung erfordern

String url = "jdbc:fabricspark://api.fabric.microsoft.com;" +
             "FabricWorkspaceID=<workspace-id>;" +
             "FabricLakehouseID=<lakehouse-id>;" +
             "AuthFlow=4;" +  
             "AuthClientID=<client-id>;" +
             "AuthCertificatePath=/path/to/certificate.pfx;" +
             "AuthCertificatePassword=<certificate-password>;" +
             "AuthTenantID=<tenant-id>;" +
             "LogLevel=INFO";

Connection conn = DriverManager.getConnection(url);

Erforderliche Parameter:

AuthFlow=4: Gibt die zertifikatbasierte Authentifizierung an.
AuthClientID: Anwendungs-ID (Client-ID)
AuthCertificatePath: Pfad zur PFX/PKCS12-Zertifikatdatei
AuthCertificatePassword: Zertifikatkennwort
AuthTenantID: Microsoft Entra Mandanten-ID

Zugriffstokenauthentifizierung

Am besten geeignet für: Benutzerdefinierte Authentifizierungsszenarien

// Acquire token through custom mechanism
String accessToken = acquireTokenFromCustomSource();

String url = "jdbc:fabricspark://api.fabric.microsoft.com;" +
             "FabricWorkspaceID=<workspace-id>;" +
             "FabricLakehouseID=<lakehouse-id>;" +
             "AuthFlow=5;" +  // Access token authentication
             "AuthAccessToken=" + accessToken + ";" +
             "LogLevel=INFO";

Connection conn = DriverManager.getConnection(url);

Zwischenspeichern der Authentifizierung

Der Treiber speichert Authentifizierungstoken automatisch zwischen, um die Leistung zu verbessern:

// Enable/disable caching (enabled by default)
String url = "jdbc:fabricspark://api.fabric.microsoft.com;" +
             "FabricWorkspaceID=<workspace-id>;" +
             "FabricLakehouseID=<lakehouse-id>;" +
             "AuthFlow=2;" +
             "AuthEnableCaching=true;" +  // Enable token caching
             "AuthCacheTTLMS=3600000";    // Cache TTL: 1 hour

Connection conn = DriverManager.getConnection(url);

Konfigurationsparameter

Erforderliche Parameter

Diese Parameter müssen in jeder Verbindungszeichenfolge vorhanden sein:

Parameter	Typ	Description	Example
`FabricWorkspaceID`	UUID	Fabric-Arbeitsbereichs-ID	`<workspace-id>`
`FabricLakehouseID`	UUID	Fabric Lakehouse-Kennkennung	`<lakehouse-id>`
`AuthFlow`	Integer	Authentifizierungsflusstyp (1-5)	`2`

Optionale Parameter

API-Versionskonfiguration

Parameter	Typ	Standard	Description
`FabricVersion`	String	`v1`	Fabric API-Version
`LivyApiVersion`	String	`2023-12-01`	API-Version von Livy

Umgebungskonfiguration

Parameter	Typ	Standard	Description
`FabricEnvironmentID`	UUID	Nichts	Fabric-Umgebungsbezeichner für das Verweisen auf das Umgebungselement für Spark-Sitzung

Spark-Konfiguration

Sitzungsressourcenkonfiguration

Konfigurieren sie Spark-Sitzungsressourcen für eine optimale Leistung:

Parameter	Typ	Standard	Description	Example
`DriverCores`	Integer	Spark-Voreinstellung	Anzahl der CPU-Kerne für Treiber	`4`
`DriverMemory`	String	Spark-Voreinstellung	Speicherzuweisung für Treiber	`4g`
`ExecutorCores`	Integer	Spark-Voreinstellung	Anzahl der CPU-Kerne pro Executor	`4`
`ExecutorMemory`	String	Spark-Voreinstellung	Speicherzuweisung pro Executor	`8g`
`NumExecutors`	Integer	Spark-Voreinstellung	Anzahl von Executors	`2`

Example:

DriverCores=4;DriverMemory=4g;ExecutorCores=4;ExecutorMemory=8g;NumExecutors=2

Benutzerdefinierte Spark-Sitzungseigenschaften

Jeder Parameter mit dem Präfix spark. wird automatisch auf die Spark-Sitzung angewendet:

Beispiel-Spark-Konfigurationen:

spark.sql.adaptive.enabled=true
spark.sql.adaptive.coalescePartitions.enabled=true
spark.sql.shuffle.partitions=200
spark.sql.autoBroadcastJoinThreshold=10485760
spark.dynamicAllocation.enabled=true
spark.dynamicAllocation.minExecutors=1
spark.dynamicAllocation.maxExecutors=10
spark.executor.memoryOverhead=1g

Natives Ausführungsmodul (NEE):

spark.nee.enabled=true

Vollständiges Beispiel:

jdbc:fabricspark://api.fabric.microsoft.com;FabricWorkspaceID=<guid>;FabricLakehouseID=<guid>;DriverMemory=4g;ExecutorMemory=8g;NumExecutors=2;spark.sql.adaptive.enabled=true;spark.nee.enabled=true;AuthFlow=2

HTTP-Client-Verbindungseinstellungen

Konfigurieren Sie die HTTP-Transportverbindungen des Treibers für optimale Netzwerkleistung. Diese Einstellungen konfigurieren oder verwalten das JDBC-Verbindungspooling nicht:

Parameter	Typ	Standard	Description
`HttpMaxTotalConnections`	Integer	100	Maximale Gesamtanzahl von HTTP-Verbindungen
`HttpMaxConnectionsPerRoute`	Integer	50	Maximale Verbindungen pro Route
`HttpConnectionTimeoutInSeconds`	Integer	30	Verbindungstimeout
`HttpSocketTimeoutInSeconds`	Integer	60	Socket-Lesetimeout
`HttpReadTimeoutInSeconds`	Integer	60	HTTP-Lesetimeout
`HttpConnectionRequestTimeoutSeconds`	Integer	30	Timeout der Verbindungsanforderung aus dem Pool
`HttpEnableKeepAlive`	Boolean	Wahr	Aktivieren von HTTP-Keep-Alive
`HttpKeepAliveTimeoutSeconds`	Integer	60	Keep-Alive-Timeout
`HttpFollowRedirects`	Boolean	Wahr	HTTP-Umleitungen folgen
`HttpUseAsyncIO`	Boolean	Falsch	Verwendung von asynchronem HTTP-E/A

Example:

HttpMaxTotalConnections=200;HttpMaxConnectionsPerRoute=100;HttpConnectionTimeoutInSeconds=60

Proxykonfiguration

Konfigurieren von HTTP- und SOCKEN-Proxyeinstellungen für Unternehmensumgebungen:

Parameter	Typ	Standard	Description
`UseProxy`	Boolean	Falsch	Proxy aktivieren
`ProxyTransport`	String	`http`	Proxy-Transporttyp (http/tcp)
`ProxyHost`	String	Nichts	Proxyhostname
`ProxyPort`	Integer	Nichts	Proxyport
`ProxyAuthEnabled`	Boolean	Falsch	Aktivieren der Proxyauthentifizierung
`ProxyUsername`	String	Nichts	Proxy-Authentifizierungsbenutzername
`ProxyPassword`	String	Nichts	Proxyauthentifizierungskennwort
`ProxyAuthScheme`	String	`basic`	Authentifizierungssystem (Basic/Digest/NTLM)
`ProxySocksVersion`	Integer	5	SOCKS-Version (4/5)

HTTP-Proxybeispiel:

UseProxy=true;ProxyTransport=http;ProxyHost=proxy.company.com;ProxyPort=8080;ProxyAuthEnabled=true;ProxyUsername=user;ProxyPassword=pass

SOCKEN-Proxybeispiel:

UseProxy=true;ProxyTransport=tcp;ProxyHost=socks.company.com;ProxyPort=1080;ProxySocksVersion=5

Protokollierungskonfiguration

Parameter	Typ	Standard	Description
`LogLevel`	String	`INFO`	Protokollierungsebene: TRACE, DEBUG, INFO, WARN, ERROR

Example:

LogLevel=DEBUG

Standardprotokollspeicherort:

${user.home}/.microsoft/livy-jdbc-driver/driver.log

Benutzerdefinierte Protokollkonfiguration: Verwenden Sie eine benutzerdefinierte log4j2.xml- oder logback.xml-Datei in Ihrem Klassenpfad.

Verwendungsbeispiele

Grundlegende Verbindung

import java.sql.*;

public class BasicConnectionExample {
    public static void main(String[] args) {
        String url = "jdbc:fabricspark://api.fabric.microsoft.com;" +
                     "FabricWorkspaceID=<workspace-id>;" +
                     "FabricLakehouseID=<lakehouse-id>;" +
                     "AuthFlow=2";
        
        try (Connection conn = DriverManager.getConnection(url)) {
            System.out.println("Connected successfully!");
            System.out.println("Database: " + conn.getMetaData().getDatabaseProductName());
            System.out.println("Driver: " + conn.getMetaData().getDriverName());
            System.out.println("Driver Version: " + conn.getMetaData().getDriverVersion());
        } catch (SQLException e) {
            System.err.println("Connection failed: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

Ausführen von Abfragen

Einfache Abfrage

public void executeSimpleQuery(Connection conn) throws SQLException {
    String sql = "SELECT current_timestamp() as now";
    
    try (Statement stmt = conn.createStatement();
         ResultSet rs = stmt.executeQuery(sql)) {
        
        if (rs.next()) {
            Timestamp now = rs.getTimestamp("now");
            System.out.println("Current timestamp: " + now);
        }
    }
}

Abfrage mit Filter

public void executeQueryWithFilter(Connection conn) throws SQLException {
    String sql = "SELECT * FROM sales WHERE amount > 1000 ORDER BY amount DESC";
    
    try (Statement stmt = conn.createStatement();
         ResultSet rs = stmt.executeQuery(sql)) {
        
        while (rs.next()) {
            int id = rs.getInt("id");
            double amount = rs.getDouble("amount");
            Date date = rs.getDate("sale_date");
            
            System.out.printf("ID: %d, Amount: %.2f, Date: %s%n", 
                            id, amount, date);
        }
    }
}

Abfrage mit Limit

public void executeQueryWithLimit(Connection conn) throws SQLException {
    String sql = "SELECT * FROM customers LIMIT 10";
    
    try (Statement stmt = conn.createStatement();
         ResultSet rs = stmt.executeQuery(sql)) {
        
        ResultSetMetaData metaData = rs.getMetaData();
        int columnCount = metaData.getColumnCount();
        
        // Print column names
        for (int i = 1; i <= columnCount; i++) {
            System.out.print(metaData.getColumnName(i) + "\t");
        }
        System.out.println();
        
        // Print rows
        while (rs.next()) {
            for (int i = 1; i <= columnCount; i++) {
                System.out.print(rs.getString(i) + "\t");
            }
            System.out.println();
        }
    }
}

Arbeiten mit Resultsets

Navigieren in Ergebnismengen

public void navigateResultSet(Connection conn) throws SQLException {
    String sql = "SELECT id, name, amount FROM orders";
    
    try (Statement stmt = conn.createStatement(
            ResultSet.TYPE_SCROLL_INSENSITIVE,
            ResultSet.CONCUR_READ_ONLY);
         ResultSet rs = stmt.executeQuery(sql)) {
        
        // Move to first row
        if (rs.first()) {
            System.out.println("First row: " + rs.getString("name"));
        }
        
        // Move to last row
        if (rs.last()) {
            System.out.println("Last row: " + rs.getString("name"));
            System.out.println("Total rows: " + rs.getRow());
        }
        
        // Move to specific row
        if (rs.absolute(5)) {
            System.out.println("Row 5: " + rs.getString("name"));
        }
    }
}

Verarbeiten großer Ergebnismengen

public void processLargeResultSet(Connection conn) throws SQLException {
    String sql = "SELECT * FROM large_table";
    
    try (Statement stmt = conn.createStatement()) {
        // Set fetch size for efficient memory usage
        stmt.setFetchSize(1000);
        
        try (ResultSet rs = stmt.executeQuery(sql)) {
            int rowCount = 0;
            while (rs.next()) {
                // Process row
                processRow(rs);
                rowCount++;
                
                if (rowCount % 10000 == 0) {
                    System.out.println("Processed " + rowCount + " rows");
                }
            }
            System.out.println("Total rows processed: " + rowCount);
        }
    }
}

private void processRow(ResultSet rs) throws SQLException {
    // Process individual row
}

Verwendung vorbereiteter Anweisungen

public void usePreparedStatement(Connection conn) throws SQLException {
    String sql = "SELECT * FROM products WHERE category = ? AND price > ?";
    
    try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
        // Set parameters
        pstmt.setString(1, "Electronics");
        pstmt.setDouble(2, 100.0);
        
        try (ResultSet rs = pstmt.executeQuery()) {
            while (rs.next()) {
                String name = rs.getString("name");
                double price = rs.getDouble("price");
                System.out.printf("Product: %s, Price: $%.2f%n", name, price);
            }
        }
    }
}

Batchvorgänge

public void executeBatchInsert(Connection conn) throws SQLException {
    String sql = "INSERT INTO logs (timestamp, level, message) VALUES (?, ?, ?)";
    
    try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
        conn.setAutoCommit(false);  // Disable auto-commit for batch
        
        // Add multiple statements to batch
        for (int i = 0; i < 1000; i++) {
            pstmt.setTimestamp(1, new Timestamp(System.currentTimeMillis()));
            pstmt.setString(2, "INFO");
            pstmt.setString(3, "Log message " + i);
            pstmt.addBatch();
            
            // Execute batch every 100 statements
            if (i % 100 == 0) {
                pstmt.executeBatch();
                pstmt.clearBatch();
            }
        }
        
        // Execute remaining statements
        pstmt.executeBatch();
        conn.commit();
        
        System.out.println("Batch insert completed successfully");
    } catch (SQLException e) {
        conn.rollback();
        throw e;
    } finally {
        conn.setAutoCommit(true);
    }
}

Verbindungspooling mit HikariCP

Konfigurieren Sie HikariCP mit der JDBC-URL so, dass Verbindungen über LivyDriver hergestellt werden. Erstellen Sie eine HikariCP-Instanz und verwenden Sie sie für die gesamte Anwendungsdauer wieder.

Maven-Abhängigkeit

<dependency>
    <groupId>com.zaxxer</groupId>
    <artifactId>HikariCP</artifactId>
    <version>5.0.1</version>
</dependency>

Konfigurieren Sie HikariCP mit der JDBC-URL

Konfigurieren Sie die JDBC-URL und die Treiberklasse so, dass HikariCP physische Verbindungen über LivyDrivererstellt. Das explizite Festlegen der Treiberklasse ist optional, wenn die automatische Erkennung von JDBC-Dienstanbietern verfügbar ist:

import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public final class DriverConnectionPoolExample {
    public static HikariDataSource createPool(String url) {
        HikariConfig config = new HikariConfig();
        config.setDriverClassName("com.microsoft.spark.livy.jdbc.LivyDriver");
        config.setJdbcUrl(url);

        // Keep pool sizes small: each classic-mode physical connection owns a Livy session.
        config.setMaximumPoolSize(2);
        config.setMinimumIdle(0);
        config.setConnectionTimeout(900000);     // Wait up to 15 minutes to borrow a connection
        config.setInitializationFailTimeout(-1); // Skip startup validation; connect on demand
        config.setIdleTimeout(600000);           // 10 minutes
        config.setMaxLifetime(1800000);          // 30 minutes
        config.setPoolName("FabricSparkDriverPool");

        return new HikariDataSource(config);
    }

    public static void main(String[] args) throws SQLException {
        String url = "jdbc:fabricspark://api.fabric.microsoft.com;" +
                     "FabricWorkspaceID=<workspace-id>;" +
                     "FabricLakehouseID=<lakehouse-id>;" +
                     "AuthFlow=AZURE_CLI;" +            // Uses the DefaultAzureCredential chain
                     "LivySessionTimeoutSeconds=600";  // Poll up to 10 minutes for session readiness

        // Reuse this pool for the application lifetime; main closes it at process exit.
        try (HikariDataSource pool = createPool(url);
             Connection conn = pool.getConnection();
             Statement stmt = conn.createStatement();
             ResultSet rs = stmt.executeQuery("SELECT 'Pooled LivyDriver connection!' as message")) {

            if (rs.next()) {
                System.out.println(rs.getString("message"));
            }
        }
    }
}

Verwenden Sie folgende Anleitung bei der Konfiguration des Pools:

Einstellung oder Verhalten	Leitlinien
`connectionTimeout`	Kontrolliert, wie lange ein Anrufer wartet, um eine Verbindung auszuleihen, bricht aber einen bereits laufenden Verbindungsversuch nicht ab. Stellen Sie den Wert höher als `LivySessionTimeoutSeconds` ein, damit genügend Zeit für die Authentifizierung, Sitzungserstellung, HTTP-Wiederholungen und die erste Validierung bleibt.
Verbindungsvalidierung	HikariCP verwendet `Connection.isValid()`. Ihre effektive Dauer wird durch die HTTP-Timeout- und Retry-/Backoff-Einstellungen des Treibers gesteuert, nicht durch `validationTimeout` von HikariCP. Konfiguriere keine Verbindungstestanfrage, weil sie die leichtere Validierungsprüfung durch eine Spark-Anweisung ersetzt.

Die vollständige Liste der HikariCP-Konfigurationsoptionen finden Sie hier:

Datentypzuordnung

Der Treiber ordnet Spark SQL-Datentypen JDBC-SQL-Typen und Java-Typen zu.

Spark SQL-Typ	JDBC SQL-Typ	Java-Typ	Hinweise
`BOOLEAN`	`BOOLEAN`	`Boolean`
`BYTE`	`TINYINT`	`Byte`
`SHORT`	`SMALLINT`	`Short`
`INT`	`INTEGER`	`Integer`
`LONG`	`BIGINT`	`Long`
`FLOAT`	`FLOAT`	`Float`
`DOUBLE`	`DOUBLE`	`Double`
`DECIMAL`	`DECIMAL`	`BigDecimal`	Genauigkeit und Skalierung erhalten
`STRING`	`VARCHAR`	`String`
`VARCHAR(n)`	`VARCHAR`	`String`
`CHAR(n)`	`CHAR`	`String`
`BINARY`	`BINARY`	`byte[]`
`DATE`	`DATE`	`java.sql.Date`
`TIMESTAMP`	`TIMESTAMP`	`java.sql.Timestamp`
`ARRAY`	`VARCHAR`	`String`	Serialisiert als JSON
`MAP`	`VARCHAR`	`String`	Serialisiert als JSON
`STRUCT`	`VARCHAR`	`String`	Serialisiert als JSON

Feedback

War diese Seite hilfreich?

Last updated on 2026-08-14

Microsoft JDBC-Treiber für Microsoft Fabric Data Engineering

Wichtige Merkmale

Voraussetzungen

Herunterladen und Installieren

Schnellstartbeispiel

Verbindungszeichenfolgenformat

Basisverbindungszeichenfolge

Verbindungskettenkomponenten

Beispielverbindungszeichenfolgen

Standardverbindung (interaktive browserbasierte Authentifizierung)

Mit Spark-Ressourcenkonfiguration

Mit Spark Session-Eigenschaften

Authentifizierung

Authentifizierungsabläufe

Interaktive Browserauthentifizierung

Client-Anmeldeinformationen oder Serviceprinzipal-Authentifizierung

zertifikatbasierte Authentifizierung

Zugriffstokenauthentifizierung

Zwischenspeichern der Authentifizierung

Konfigurationsparameter

Erforderliche Parameter

Optionale Parameter

API-Versionskonfiguration

Umgebungskonfiguration

Spark-Konfiguration

Sitzungsressourcenkonfiguration

Benutzerdefinierte Spark-Sitzungseigenschaften

HTTP-Client-Verbindungseinstellungen

Proxykonfiguration

Protokollierungskonfiguration

Verwendungsbeispiele

Grundlegende Verbindung

Ausführen von Abfragen

Einfache Abfrage

Abfrage mit Filter

Abfrage mit Limit

Arbeiten mit Resultsets

Navigieren in Ergebnismengen

Verarbeiten großer Ergebnismengen

Verwendung vorbereiteter Anweisungen

Batchvorgänge

Verbindungspooling mit HikariCP

Maven-Abhängigkeit

Konfigurieren Sie HikariCP mit der JDBC-URL

Datentypzuordnung

Verwandte Inhalte

Feedback

Zusätzliche Ressourcen