Microsoft ODBC-drivrutin för Microsoft Fabric Data Engineering

ODBC (Open Database Connectivity) är en allmänt antagen standard som gör det möjligt för klientprogram att ansluta till och arbeta med data från databaser och stordataplattformar.

Microsoft ODBC Driver för Fabric Data Engineering låter dig koppla in, fråga och hantera Spark-arbetsbelastningar i Fabric med samma tillförlitlighet och enkelhet som ODBC-standarden. Byggd på Fabric:s Livy-API:er tillhandahåller drivrutinen säker och flexibel Spark SQL-anslutning till dina C/C++, .NET, Python och andra ODBC-kompatibla applikationer och BI-verktyg.

Viktiga funktioner

• ODBC 3.x-kompatibel: Fullständig implementering av ODBC 3.x-specifikation
• Microsoft Entra ID autentisering: Flera autentiseringsflöden, inklusive Azure CLI, interaktiv, klientautentiseringsuppgifter, certifikatbaserad och åtkomsttokenautentisering
• Stöd för Spark SQL-frågor: Direkt körning av Spark SQL-instruktioner
• Omfattande stöd för datatyper: Stöd för alla Spark SQL-datatyper, inklusive komplexa typer (ARRAY, MAP, STRUCT)
• Återanvändning av sessioner: Inbyggd sessionshantering för bättre prestanda
• Högsamtidighetsläge: Välj in delade, varma server-side Livy-sessioner för att minska uppstartsfördröjning vid anslutningen och Spark-klusterets spridning
• Stöd för stora tabeller: Optimerad hantering för stora resultatuppsättningar med konfigurerbara sidstorlekar
• Async prefetch: Inläsning av bakgrundsdata för bättre prestanda
• Proxystöd: HTTP-proxykonfiguration för företagsmiljöer
• Stöd för flera scheman i lakehouse: Anslut till ett specifikt schema i ett lakehouse
• OneLake-integration: Åtkomst till lakehouse-data lagrad i OneLake, inklusive tabeller över flera scheman, via ett enhetligt ODBC-gränssnitt utan separat lagringskonfiguration
• Stöd för miljöobjekt: Koppla Fabric-miljöobjekt under jobbkörningen för att tillämpa arbetsytebibliotek, Spark-egenskaper och variabler på varje session.
• Anpassad Spark-konfiguration: Skicka Spark-konfigurationsegenskaper direkt via reťazec pripojenia för att justera sessionsbeteendet

Förutsättningar

Kontrollera att du har följande innan du använder Microsoft ODBC-drivrutinen för Microsoft Fabric Data Engineering:

• Operativsystem: Windows 10/11 eller Windows Server 2016+
• Fabric Access: Tillgång till en arbetsyta för Fabric
• Microsoft Entra ID-autentiseringsuppgifter: Lämpliga uppgifter för autentisering
• Arbetsyte- och lakehouse-ID:n: GUID-identifierare för din Fabric-arbetsyta och ditt lakehouse
• Azure CLI (valfritt): Krävs för Azure CLI-autentiseringsmetod

Ladda ned och MSI-installation

• Ladda ned Microsoft ODBC-drivrutin för Microsoft Fabric Data Engineering (zip)

1. Ladda ned Microsoft ODBC-drivrutin för Microsoft Fabric Data Engineering MSI-paketet
2. Dubbelklicka på MicrosoftFabricODBCDriver-2.0.msi.
3. Följ installationsguiden och godkänn licensavtalet
4. Välj installationskatalog (standard: C:\Program Files\Microsoft ODBC Driver for Microsoft Fabric Data Engineering\)
5. Slutför installationen

Tyst installation

# Silent installation
msiexec /i "MicrosoftFabricODBCDriver-2.0.msi" /quiet

# Installation with logging
msiexec /i "MicrosoftFabricODBCDriver-2.0.msi" /l*v install.log

Verifiera installationen

Efter installationen, kontrollera att drivrutinen har registrerats:

1. Kör odbcad32.exe (ODBC-datakäll­administratör)
2. Gå till fliken Drivrutiner
3. Kontrollera att "Microsoft ODBC-drivrutin för Microsoft Fabric Data Engineering" visas

Snabbstartsexempel

Detta exempel visar hur man ansluter till Fabric och kör en fråga med Microsoft ODBC Driver för Microsoft Fabric Data Engineering. Innan du kör den här koden kontrollerar du att du har slutfört förutsättningarna och installerat drivrutinen.

C/C++-exempel

#include <windows.h>
#include <sql.h>
#include <sqlext.h>
#include <iostream>

int main() {
    SQLHENV environment = SQL_NULL_HENV;
    SQLHDBC connection = SQL_NULL_HDBC;
    SQLHSTMT statement = SQL_NULL_HSTMT;

    SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &environment);
    SQLSetEnvAttr(
        environment,
        SQL_ATTR_ODBC_VERSION,
        (SQLPOINTER)SQL_OV_ODBC3,
        0);
    SQLAllocHandle(SQL_HANDLE_DBC, environment, &connection);

    const char* connectionString =
        "DRIVER={Microsoft ODBC Driver for Microsoft Fabric Data Engineering};"
        "WorkspaceId=<workspace-id>;"
        "LakehouseId=<lakehouse-id>;"
        "AuthFlow=AZURE_CLI;";

    SQLRETURN result = SQLDriverConnectA(
        connection,
        NULL,
        (SQLCHAR*)connectionString,
        SQL_NTS,
        NULL,
        0,
        NULL,
        SQL_DRIVER_NOPROMPT);

    if (SQL_SUCCEEDED(result)) {
        SQLAllocHandle(SQL_HANDLE_STMT, connection, &statement);
        result = SQLExecDirectA(
            statement,
            (SQLCHAR*)"SELECT 'Hello from Fabric!' AS message",
            SQL_NTS);

        if (SQL_SUCCEEDED(result)) {
            char message[256];
            SQLLEN indicator;

            while (SQLFetch(statement) == SQL_SUCCESS) {
                SQLGetData(
                    statement,
                    1,
                    SQL_C_CHAR,
                    message,
                    sizeof(message),
                    &indicator);
                std::cout << message << std::endl;
            }
        }

        SQLFreeHandle(SQL_HANDLE_STMT, statement);
        SQLDisconnect(connection);
    }

    SQLFreeHandle(SQL_HANDLE_DBC, connection);
    SQLFreeHandle(SQL_HANDLE_ENV, environment);
    return 0;
}

Python-exempel

import pyodbc

# Connection string with required parameters
connection_string = (
    "DRIVER={Microsoft ODBC Driver for Microsoft Fabric Data Engineering};"
    "WorkspaceId=<workspace-id>;"
    "LakehouseId=<lakehouse-id>;"
    "AuthFlow=AZURE_CLI;"
)

# Connect and execute query
conn = pyodbc.connect(connection_string, timeout=30)
cursor = conn.cursor()

cursor.execute("SELECT 'Hello from Fabric!' as message")
row = cursor.fetchone()
print(row.message)

conn.close()

.NET-exempel

using System.Data.Odbc;

// Connection string with required parameters
string connectionString = 
    "DRIVER={Microsoft ODBC Driver for Microsoft Fabric Data Engineering};" +
    "WorkspaceId=<workspace-id>;" +
    "LakehouseId=<lakehouse-id>;" +
    "AuthFlow=AZURE_CLI;";

using var connection = new OdbcConnection(connectionString);
await connection.OpenAsync();

Console.WriteLine("Connected successfully!");

using var command = new OdbcCommand("SELECT 'Hello from Fabric!' as message", connection);
using var reader = await command.ExecuteReaderAsync();

if (await reader.ReadAsync())
{
    Console.WriteLine(reader.GetString(0));
}

Format för anslutningssträng

Grundläggande anslutningssträng

Microsoft ODBC-drivrutinen för Microsoft Fabric Data Engineering använder följande format för anslutningssträngar:

DRIVER={Microsoft ODBC Driver for Microsoft Fabric Data Engineering};<parameter1>=<value1>;<parameter2>=<value2>;...

Anslutningssträngskomponenter

Exempel på anslutningssträngar

Grundläggande anslutning (Azure CLI-autentisering)

DRIVER={Microsoft ODBC Driver for Microsoft Fabric Data Engineering};WorkspaceId=<workspace-id>;LakehouseId=<lakehouse-id>;AuthFlow=AZURE_CLI

Med prestandaalternativ

DRIVER={Microsoft ODBC Driver for Microsoft Fabric Data Engineering};WorkspaceId=<workspace-id>;LakehouseId=<lakehouse-id>;AuthFlow=AZURE_CLI;ReuseSession=true;LargeTableSupport=true;PageSizeBytes=18874368

Med loggning

DRIVER={Microsoft ODBC Driver for Microsoft Fabric Data Engineering};WorkspaceId=<workspace-id>;LakehouseId=<lakehouse-id>;AuthFlow=AZURE_CLI;LogLevel=DEBUG;LogFile=odbc_driver.log

Med läge för hög samtidighet

DRIVER={Microsoft ODBC Driver for Microsoft Fabric Data Engineering};WorkspaceId=<workspace-id>;LakehouseId=<lakehouse-id>;AuthFlow=AZURE_CLI;LivyMode=HighConcurrency;SessionTag=bi-dashboard

Se avsnittet omHigh-Concurrency (HC) Mode för fullständig konfigurationsvägledning.

Authentication

Microsoft ODBC-drivrutinen för Microsoft Fabric Data Engineering stöder flera autentiseringsmetoder via Microsoft Entra-ID (tidigare Azure Active Directory). Autentisering konfigureras med hjälp av parametern AuthFlow i anslutningssträngen.

Autentiseringsmetoder

Du kan ange autentiseringsvärden i upper snake case, Pascal case eller numerisk form. Föraren accepterar också korta alias såsom Browser, , , CLI, CertificateToken, och FileInteractive. Föraren ignorerar understreck när den jämför värden.

Azure CLI-autentisering

Bäst för: Utveckling och interaktiva program

# Python Example
connection_string = (
    "DRIVER={Microsoft ODBC Driver for Microsoft Fabric Data Engineering};"
    "WorkspaceId=<workspace-id>;"
    "LakehouseId=<lakehouse-id>;"
    "AuthFlow=AZURE_CLI;"
    "Scope=https://api.fabric.microsoft.com/.default;"
)
conn = pyodbc.connect(connection_string)

Prerequisites:

• Azure CLI installerat: az --version
• Inloggad: az login

Interaktiv webbläsarautentisering

Bäst för: Användarinriktade program

# Python Example
connection_string = (
    "DRIVER={Microsoft ODBC Driver for Microsoft Fabric Data Engineering};"
    "WorkspaceId=<workspace-id>;"
    "LakehouseId=<lakehouse-id>;"
    "AuthFlow=INTERACTIVE;"
    "TenantId=<tenant-id>;"
    "Scope=https://api.fabric.microsoft.com/.default;"
)
conn = pyodbc.connect(connection_string)

Beteende:

• Öppnar ett webbläsarfönster för användarautentisering
• Autentiseringsuppgifter cachelagras för efterföljande anslutningar

Klientautentiseringsuppgifter (tjänstens huvudnamn) autentisering

Bäst för: Automatiserade tjänster och bakgrundsjobb

connection_string = (
    "DRIVER={Microsoft ODBC Driver for Microsoft Fabric Data Engineering};"
    "WorkspaceId=<workspace-id>;"
    "LakehouseId=<lakehouse-id>;"
    "AuthFlow=CLIENT_CREDENTIAL;"
    f"TenantId={tenant_id};"
    f"ClientId={client_id};"
    f"ClientSecret={client_secret};"
)

Obligatoriska parametrar

• TenantId: Azure-klientorganisations-ID
• ClientId: Program-ID (klient) från Microsoft Entra-ID
• ClientSecret: Klienthemlighet från Microsoft Entra-ID

Bästa praxis

• Lagra hemligheter på ett säkert sätt (Azure Key Vault, miljövariabler)
• Använda hanterade identiteter när det är möjligt
• Rotera hemligheter regelbundet

Certifikatbaserad autentisering

Bäst för: Företagsprogram som kräver certifikatbaserad autentisering

connection_string = (
    "DRIVER={Microsoft ODBC Driver for Microsoft Fabric Data Engineering};"
    "WorkspaceId=<workspace-id>;"
    "LakehouseId=<lakehouse-id>;"
    "AuthFlow=CLIENT_CERTIFICATE;"
    "TenantId=<tenant-id>;"
    "ClientId=<client-id>;"
    "CertificatePath=C:\\certs\\mycert.pfx;"
    "CertificatePassword=<password>;"
)

Obligatoriska parametrar:

• TenantId: Azure-klientorganisations-ID
• ClientId: Program-ID (klient)-ID
• CertificatePath: Sökväg till PFX/PKCS12-certifikatfilen
• CertificatePassword: Certifikatlösenord

Åtkomsttokenautentisering

Bäst för: Scenarier för anpassad autentisering

# Acquire token through custom mechanism
access_token = acquire_token_from_custom_source()

connection_string = (
    "DRIVER={Microsoft ODBC Driver for Microsoft Fabric Data Engineering};"
    "WorkspaceId=<workspace-id>;"
    "LakehouseId=<lakehouse-id>;"
    "AuthFlow=ACCESS_TOKEN;"
    f"AccessToken={access_token};"
)

Autentisering med filtoken

Använd filtokenautentisering för containeriserade miljöer och automatiserade pipelines där en annan process skriver en bärartoken till drivrutinens välkända tokenfil:

connection_string = (
    "DRIVER={Microsoft ODBC Driver for Microsoft Fabric Data Engineering};"
    "WorkspaceId=<workspace-id>;"
    "LakehouseId=<lakehouse-id>;"
    "AuthFlow=FILE_TOKEN;"
)

Drivrutinen löser tokenfilens plats på Windows och Linux.

Alias för egenskaper mellan drivrutiner

ODBC-drivrutinen accepterar utvalda ADO.NET- och JDBC-egendomsnamn utöver de ursprungliga ODBC-namnen. Detta stöd kan minska förändringar i anslutningssträngar när du byter mellan Fabric-drivrutiner.

Drivrutinen löser 17 drivrutinsövergripande alias vid anslutning.

Konfigurationsparametrar

Obligatoriska parametrar

Dessa parametrar måste finnas i varje anslutningssträng:

Valfria parametrar

Anslutningsinställningar

Prestandainställningar

Loggningsinställningar

Proxyinställningar

Inställningar för hög samtidighet (HC)

Använd dessa parametrar för att aktivera och konfigurera högkonkurrensläge (HC). HC-läget är frivilligt. Om du inte ställer LivyMode in eller UseHighConcurrency, använder drivrutinen den klassiska enkelsessionsvägen. Vägledning och exempel finns i läge för hög samtidighet (HC).

Lägesprioritering och validering

• LivyMode Har företräde framför UseHighConcurrency när du sätter båda parametrarna.
• Parametervärden är inte kasuskänsliga.
• UseHighConcurrency accepterar true, 1, , yes, eller on aktiverar HC-läge. Den accepterar false, 0, no eller off för att inaktivera HC-läget.
• För andra icke-tomma värden returnerar SQLDriverConnect ett fel. DSN-endast SQLConnect loggar valideringsfelet och använder den klassiska vägen.

Kompatibilitetsinställningar

Drivrutinen accepterar TenantPrincipal och PoolMax, inklusive deras miljövariabler för att säkerställa kompatibilitet med tidigare HC-konfigurationer. Drivrutinen tolkar och validerar dessa värden, men de påverkar inte HC-sessionsmatchning eller körtidspoolens kapacitet. Lita inte på dem för isolering av hyresgäster eller anslutningsbegränsningar.

Reservlösningar för miljövariabler

Drivrutinen använder följande miljövariabler endast när motsvarande DSN- eller anslutningssträngsparameter inte är satt:

För FABRIC_ODBC_USE_HC känner aktivering endast för miljö igen true, 1 eller yes (skiftlägesokänsligt). Andra värden gör att HC förblir inaktiverat. Och onoff aliasen gäller endast för DSN- och anslutningssträngsvärden.

Miljöinställningar

Du kan koppla ett Fabric miljöobjekt till Spark-sessionen som startades av drivrutinen. Den valda miljöns bibliotek, Spark-egenskaper och variabler tillämpas automatiskt när sessionen skapas.

Exempel på anslutningssträng med en miljöparameter:

DRIVER={Microsoft ODBC Driver for Microsoft Fabric Data Engineering};WorkspaceId=<workspace-id>;LakehouseId=<lakehouse-id>;AuthFlow=AZURE_CLI;EnvironmentId=<environment-id>

Anpassad Spark-konfiguration

Du kan skicka Spark-konfigurationsegenskaper direkt i reťazec pripojenia. Alla parametrar som är försedda med prefixet spark. tillämpas automatiskt på Spark-sessionen vid skapandet, vilket gör det möjligt för dig att åsidosätta arbetsytans eller körningens standardvärden.

Exempel på Spark-konfigurationer:

spark.sql.shuffle.partitions=200
spark.sql.adaptive.enabled=true
spark.sql.autoBroadcastJoinThreshold=10485760

Example reťazec pripojenia med anpassade Spark-egenskaper:

DRIVER={Microsoft ODBC Driver for Microsoft Fabric Data Engineering};WorkspaceId=<workspace-id>;LakehouseId=<lakehouse-id>;AuthFlow=AZURE_CLI;spark.sql.shuffle.partitions=200;spark.sql.adaptive.enabled=true

Läge för hög samtidighet (HC)

High-concurrency (HC)-läge låter ODBC-anslutningar till samma arbetsyta och lakehouse ansluta till delade, varma server-sida Livy Spark-sessioner istället för att provisionera ett separat kluster för varje anslutning. Använd det för arbetsbelastningar som BI-dashboards, notebook-kärnor och ETL-fan-out som öppnar många kortvariga anslutningar och kan dela serverhanterad Spark-kapacitet.

HC-läget är frivilligt. Om du inte konfigurerar en HC-inställning använder drivrutinen den klassiska enkelsessionsvägen.

Välj ett anslutningsläge

Använd HC-läge när:

• Din arbetsbelastning öppnar många kortvariga ODBC-anslutningar, till exempel BI-paneler, notebook-kärnor eller ETL-förgreningar.
• Anslutningar riktar sig mot samma arbetsyta och lakehouse och kan dela en serverhanterad Spark-session.
• Att minska kallstartslatens per anslutning är viktigt.

Använd klassiskt läge när:

• Varje anslutning kräver en isolerad Spark-session på grund av olika Spark-konfigurationer eller strikt resursisolering.
• Fabric Livy-endpointen för målarbetsytan och lakehouse stöder inte HC-läge.

Aktivera läge för hög samtidighet

Lägg till en parameter för hög samtidighet i DSN:en eller anslutningssträngen.

Rekommenderat: Set LivyMode

Använd LivyMode för att explicit välja sessionsinhämtningsläget:

LivyMode=HighConcurrency

Värden som stöds är Classic, HighConcurrencyoch Auto. Värden är inte skiftlägeskänsliga. Auto Väljer för närvarande klassiskt läge.

Alternativ: Ange UseHighConcurrency

Använd den booleska inställningen för kompatibilitet med befintliga konfigurationer:

UseHighConcurrency=true

För att aktivera läge för hög samtidighet använder du true, 1, yes eller on. För att inaktivera den, använd false, 0, , noeller off. Värden är inte skiftlägeskänsliga. SQLDriverConnect förkastar andra icke-tomma värden med SQLSTATE HY024. DSN-endast SQLConnect loggar valideringsfelet och använder klassiskt läge.

Nödvändiga parametrar i HC-läge

HC-aktivering kräver följande giltiga identifierare:

Inkludera SessionTag eftersom det påverkar matchningen på serversidan för uppvärmda sessioner.

Matchning av sessioner

HC-läget garanterar inte att varje anslutning återanvänder en befintlig session. För varje sessionsinhämtningsbegäran skickar drivrutinen:

• Värdet SessionTag.
• Den effektiva Spark-konfigurationen, inklusive conf.* inställningar och EnvironmentId.

Fabric Livy-tjänsten utvärderar dessa värden och beslutar om kopplingen ska kopplas till en varm session eller skapas en ny. För att förbättra återanvändning av sessioner, använd konsekventa värden över anslutningar som är avsedda att dela serverhanterad Spark-kapacitet.

Exempel på anslutningssträngar

Minimal HC-anslutning (Azure CLI-autentisering):

DRIVER={Microsoft ODBC Driver for Microsoft Fabric Data Engineering};WorkspaceId=<workspace-id>;LakehouseId=<lakehouse-id>;AuthFlow=AZURE_CLI;LivyMode=HighConcurrency;SessionTag=bi-dashboard

HC med anpassade tidsgränser:

DRIVER={Microsoft ODBC Driver for Microsoft Fabric Data Engineering};WorkspaceId=<workspace-id>;LakehouseId=<lakehouse-id>;AuthFlow=AZURE_CLI;LivyMode=HighConcurrency;SessionTag=etl-prod;AcquireTimeoutSeconds=180;HeartbeatTimeoutInSecond=600

HC med en miljö och åsidosättningar för Spark-konfigurationen:

DRIVER={Microsoft ODBC Driver for Microsoft Fabric Data Engineering};WorkspaceId=<workspace-id>;LakehouseId=<lakehouse-id>;AuthFlow=AZURE_CLI;LivyMode=HighConcurrency;EnvironmentId=<environment-id>;SessionTag=ml-team;conf.spark.sql.shuffle.partitions=200;conf.spark.executor.memory=8g

Python (pyodbc):

import pyodbc

conn = pyodbc.connect(
    "DRIVER={Microsoft ODBC Driver for Microsoft Fabric Data Engineering};"
    "WorkspaceId=<workspace-id>;"
    "LakehouseId=<lakehouse-id>;"
    "AuthFlow=AZURE_CLI;"
    "LivyMode=HighConcurrency;"
    "SessionTag=notebook-kernel"
)

Konfigurera HC-läge i en DSN

Du kan lagra HC-inställningar i en DSN istället för att upprepa dem i varje reťazec pripojenia. När en reťazec pripojenia inte specificerar något värde, läser drivrutinen dessa inställningar från DSN:n:

• LivyMode
• UseHighConcurrency
• EnvironmentId
• SessionTag
• IdempotencyKey
• HeartbeatTimeoutInSecond
• AcquireTimeoutSeconds

Drivrutinen läser också inställningarna TenantPrincipal och PoolMax, som endast är avsedda för kompatibilitet. För att spara dessa inställningar redigerar du DSN:en i odbcad32.exe eller använder SQLWritePrivateProfileString. Använd parameternamnen i HC-inställningstabellen.

Inaktivera HC-läget

Du kan inaktivera att nya HC-sessioner hämtas utan att driftsätta om drivrutinen. Använd metoden som motsvarar hur du aktiverade HC-läget:

Anslutningssträngs- och DSN-inställningar har företräde framför miljövariabelns fallback. Dessa förändringar påverkar endast nya anslutningar. Befintliga HC-sessioner fortsätter tills de släpps.

Förstå HC:s körtidsbeteende

• Validering:SQLDriverConnect avvisar ogiltiga HC Booleska och positiva heltalsvärden med SQLSTATE HY024. Den avvisar en ogiltig LivyMode samt ogiltiga eller för stora WorkspaceId-, LakehouseId- och IdempotencyKey-värden med SQLSTATE-koden HY000. Ett för stort kompatibilitetsvärde returnerar också HY000. För endast SQLConnectDSN loggar drivrutinen vanliga HC-valideringsfel och använder klassiskt läge. Överdimensionerade säkerhetskänsliga värden misslyckas fortfarande med anslutningen.
• Känslig data: Drivrutinen utesluter eller raderar IdempotencyKey andra känsliga fält från HC-loggar och diagnostiska utdata.
• Avbrytning: Avbrytning av satsen sker kooperativt. Pågående serverprocesser fasas ut på ett kontrollerat sätt i stället för att avbrytas omedelbart.
• Automatsäkringar: HC-läge och klassiskt läge använder separata automatsäkringar. Att tömma ett läge påverkar inte det andra.
• Initialdatabas: HC-anslutningar exekverar inte den initiala USE satsen för parametern Database . Kör USE <database> efter anslutning eller använd fullt kvalificerade tabellnamn.
• Diagnostik: Ställ LogLevel=DEBUG in för att logga beslut om HC-förvärv, polling, release och felkartläggning. För riktad felsökning anger du LIVY_HC_VERBOSE=1 så att ytterligare sanerad HC HTTP-diagnostik inkluderas.

Konfigurera ett DSN

Skapa ett system-DSN

1. Öppna ODBC-administratör

   %SystemRoot%\System32\odbcad32.exe
   

2. Skapa nytt system-DSN

   • Gå till fliken System DSN
   • Välj Lägg till
   • Välj "Microsoft ODBC-drivrutin för Microsoft Fabric Data Engineering"
   • Välj "Slutför"

3. Konfigurera DSN-inställningar

   • Namn på datakälla: Ange ett unikt namn (t.ex. FabricODBC)
   • Beskrivning: Valfri beskrivning
   • Arbetsyte-ID: Ditt GUID för arbetsytan
   • Lakehouse-ID: Ditt Fabric Lakehouse GUID
   • Autentisering: Välj autentiseringsmetod
   • Environment ID (valfritt): Ange GUID för det Fabric miljöobjekt som ska bifogas när sessionen skapas
   • Livy-läge (valfritt): Ställt in på HighConcurrency för att aktivera HC-läge
   • Sessionstagg (valfritt): Ange en icke-känslig operativ etikett för HC-sessionsmatchning
   • Konfigurera ytterligare inställningar efter behov

4. Testanslutning

   • Välj "Testa anslutning" för att verifiera inställningarna
   • Välj "OK" för att spara

Använda DSN i program

# Python - Connect using DSN
conn = pyodbc.connect("DSN=FabricODBC")

// .NET - Connect using DSN
using var connection = new OdbcConnection("DSN=FabricODBC");
await connection.OpenAsync();

Exempel på användning

Grundläggande anslutning och fråga

python

import pyodbc

def main():
    connection_string = (
        "DRIVER={Microsoft ODBC Driver for Microsoft Fabric Data Engineering};"
        "WorkspaceId=<workspace-id>;"
        "LakehouseId=<lakehouse-id>;"
        "AuthFlow=AZURE_CLI;"
        "ReuseSession=true;"
    )
    
    conn = pyodbc.connect(connection_string, timeout=30)
    cursor = conn.cursor()
    
    print("Connected successfully!")
    
    # Show available tables
    print("\nAvailable tables:")
    cursor.execute("SHOW TABLES")
    for row in cursor.fetchall():
        print(f"  {row}")
    
    # Query data
    print("\nQuery results:")
    cursor.execute("SELECT * FROM employees LIMIT 10")
    
    # Print column names
    columns = [desc[0] for desc in cursor.description]
    print(f"Columns: {columns}")
    
    # Print rows
    for row in cursor.fetchall():
        print(row)
    
    conn.close()

if __name__ == "__main__":
    main()

.NET

using System.Data.Odbc;

class Program
{
    static async Task Main(string[] args)
    {
        string connectionString = 
            "DRIVER={Microsoft ODBC Driver for Microsoft Fabric Data Engineering};" +
            "WorkspaceId=<workspace-id>;" +
            "LakehouseId=<lakehouse-id>;" +
            "AuthFlow=AZURE_CLI;" +
            "ReuseSession=true;";

        using var connection = new OdbcConnection(connectionString);
        await connection.OpenAsync();
        
        Console.WriteLine("Connected successfully!");

        // Show available tables
        Console.WriteLine("\nAvailable tables:");
        using (var cmd = new OdbcCommand("SHOW TABLES", connection))
        using (var reader = await cmd.ExecuteReaderAsync())
        {
            while (await reader.ReadAsync())
            {
                Console.WriteLine($"  {reader.GetString(0)}");
            }
        }

        // Query data
        Console.WriteLine("\nQuery results:");
        using (var cmd = new OdbcCommand("SELECT * FROM employees LIMIT 10", connection))
        using (var reader = await cmd.ExecuteReaderAsync())
        {
            // Print column names
            var columns = new List<string>();
            for (int i = 0; i < reader.FieldCount; i++)
            {
                columns.Add(reader.GetName(i));
            }
            Console.WriteLine($"Columns: {string.Join(", ", columns)}");

            // Print rows
            while (await reader.ReadAsync())
            {
                var values = new object[reader.FieldCount];
                reader.GetValues(values);
                Console.WriteLine(string.Join("\t", values));
            }
        }
    }
}

Arbeta med stora resultatuppsättningar

import pyodbc

connection_string = (
    "DRIVER={Microsoft ODBC Driver for Microsoft Fabric Data Engineering};"
    "WorkspaceId=<workspace-id>;"
    "LakehouseId=<lakehouse-id>;"
    "AuthFlow=AZURE_CLI;"
    "LargeTableSupport=true;"
    "PageSizeBytes=18874368;"  # 18 MB pages
    "EnableAsyncPrefetch=1;"
)

conn = pyodbc.connect(connection_string)
cursor = conn.cursor()

# Execute large query
cursor.execute("SELECT * FROM large_table")

# Process in batches
row_count = 0
while True:
    rows = cursor.fetchmany(1000)  # Fetch 1000 rows at a time
    if not rows:
        break
    
    for row in rows:
        # Process row
        row_count += 1
        
    if row_count % 10000 == 0:
        print(f"Processed {row_count} rows")

print(f"Total rows processed: {row_count}")
conn.close()

Kör DML-satser

bool executeDml(SQLHDBC connection, const char* sql, const char* description) {
    SQLHSTMT statement = SQL_NULL_HSTMT;
    SQLAllocHandle(SQL_HANDLE_STMT, connection, &statement);

    std::cout << "Executing: " << description << std::endl;
    SQLRETURN result = SQLExecDirectA(
        statement,
        (SQLCHAR*)sql,
        SQL_NTS);

    bool succeeded = SQL_SUCCEEDED(result);
    if (succeeded) {
        SQLLEN rowCount;
        SQLRowCount(statement, &rowCount);
        std::cout << "Rows affected: " << rowCount << std::endl;
    }

    SQLFreeHandle(SQL_HANDLE_STMT, statement);
    return succeeded;
}

Använd executeDml med INSERT, UPDATE, eller DELETE satser. Det rapporterade radantalet beror på om resultatet innehåller ett antal uppdaterade rader som drivrutinen känner igen.

Upptäckt av schema

import pyodbc

conn = pyodbc.connect(connection_string)
cursor = conn.cursor()

# List all tables
print("Tables in current default schema / database:")
cursor.execute("SHOW TABLES")
tables = cursor.fetchall()
for table in tables:
    print(f"  {table}")

# Describe table structure
print("\nTable structure for 'employees':")
cursor.execute("DESCRIBE employees")
for col in cursor.fetchall():
    print(f"  {col}")

# List schemas (for multi-schema Lakehouses)
print("\nAvailable schemas:")
cursor.execute("SHOW SCHEMAS")
for db in cursor.fetchall():
    print(f"  {db}")

conn.close()

Datatypkartläggning

Drivrutinen mappar Spark SQL-datatyper till ODBC SQL-typer:

BI-verktygsintegrering

Microsoft Excel

1. Öppna Excel –> Data –> Hämta data –> från andra källor –> från ODBC
2. Välj ditt konfigurerade DSN (t.ex. FabricODBC)
3. Autentisera om du uppmanas att göra det
4. Bläddra bland och välj tabeller
5. Läsa in data i Excel-kalkylblad

Power BI Desktop

1. Öppna Power BI Desktop –> Hämta data –> ODBC
2. Välj ditt konfigurerade DSN
3. Bläddra i datakatalogen och välj tabeller
4. Transformera data efter behov
5. Skapa visualiseringar

SQL Server Management Studio (Länkad Server)

-- Create linked server
EXEC sp_addlinkedserver 
    @server = 'FABRIC_LINKED_SERVER',
    @srvproduct = 'Microsoft Fabric',
    @provider = 'MSDASQL',
    @datasrc = 'FabricODBC'

-- Configure RPC
EXEC master.dbo.sp_serveroption 
    @server = N'FABRIC_LINKED_SERVER',
    @optname = N'rpc out',
    @optvalue = N'true';

-- Query via linked server
SELECT * FROM OPENQUERY(FABRIC_LINKED_SERVER, 'SHOW TABLES');
SELECT * FROM OPENQUERY(FABRIC_LINKED_SERVER, 'SELECT * FROM employees LIMIT 20');

-- Execute statements
EXEC('SELECT * FROM employees LIMIT 10') AT FABRIC_LINKED_SERVER;

Felsökning

Det här avsnittet innehåller vägledning för att lösa vanliga problem som kan uppstå när du använder Microsoft ODBC-drivrutinen för Microsoft Fabric Data Engineering.

Vanliga problem

I följande avsnitt beskrivs vanliga problem och deras lösningar:

Anslutningsfel

Problem: Kan inte ansluta till Fabric

Lösningar:

1. Kontrollera att arbetsyte-ID och lakehouse-ID är giltiga GUID:er
2. Kontrollera Azure CLI-autentisering: az account show
3. Se till att du har rätt behörigheter för Fabric-arbetsyta
4. Kontrollera nätverksanslutningen och proxyinställningarna

Autentiseringsfel

Problem: Autentiseringen misslyckas med Azure CLI

Lösningar:

• Kör az login för att uppdatera autentiseringsuppgifter
• Verifiera rätt klient: az account set --subscription <subscription-id>
• Kontrollera tokens giltighet: az account get-access-token --resource https://api.fabric.microsoft.com

Timeout för frågor

Problem: Frågor som överskrider tidsgränsen för stora tabeller

Lösningar:

• Aktivera LargeTableSupport=true
• Justera PageSizeBytes för optimal segmentstorlek
• Aktivera asynkron prefetch: EnableAsyncPrefetch=1
• Använd LIMIT -sats för att begränsa resultatstorleken

Aktivera loggning

När du felsöker problem kan du identifiera rotorsaken till problem genom att aktivera detaljerad loggning. Du kan aktivera loggning via anslutningssträngen.

Så här aktiverar du detaljerad loggning:

LogLevel=DEBUG;LogFile=C:\temp\odbc_driver_debug.log;

Loggnivåer:

• DEBUG: Detaljerad felsökningsinformation och den mest utförliga loggnivån för drivrutinen
• INFO: Allmän information (standard)
• WARN: Endast varningar
• ERROR: Endast fel

ODBC-spårning

För lågnivådiagnostik kan du aktivera Windows ODBC-spårning för att samla in detaljerade ODBC API-anrop och drivrutinsbeteende. Kom ihåg att inaktivera spårning när det inte behövs för att upprätthålla optimala prestanda.

Så här aktiverar du ODBC-spårning:

1. Öppna odbcad32.exe
2. Gå till fliken "Spårning"
3. Ange sökväg för spårningsfiler (t.ex. C:\temp\odbctrace.log)
4. Välj "Starta spårning nu"
5. Återskapa problemet
6. Välj "Stoppa spårning nu"

Relaterat innehåll

• Microsoft ODBC-drivrutin för Microsoft Fabric Data Engineering på Linux
• Apache Spark Runtimes på plattformen
• Fabric-körmiljö 1.3
• Vad är Livy API för datateknik
• Microsoft JDBC-drivrutin för Microsoft Fabric Data Engineering