Snabbstart: Snabb prototypkörning med drivrutinen mssql-python för Python

I denna snabbstart använder du Streamlit för att snabbt skapa en rapport, så att du kan samla in användarfeedback tidigt. Du använder drivrutinen mssql-python för Python för att ansluta till din databas och läsa in datan som laddas in i din rapport.

Drivrutinen mssql-python kräver inga externa beroenden på Windows-datorer. Drivrutinen installerar allt som behövs med en enda pip installation, så att du kan använda den senaste versionen av drivrutinen för nya skript utan att bryta andra skript som du inte har tid att uppgradera och testa.

mssql-python-dokumentation | mssql-python-källkod | Paket (PyPI) | Uv

Förutsättningar

Python 3.10 eller senare.
Om du inte redan har Python installerar du Python-körnings - och pip-pakethanteraren från python.org.
Vill du inte använda din egen miljö? Använd Container- och lokal utveckling för att skapa en reproducerbar devcontainer eller en GitHub Codespaces-miljö.
Visual Studio Code med följande tillägg:
- Python-tillägg för Visual Studio Code
Azure Command-Line Interface (CLI) för lösenordslös autentisering i macOS och Linux.
Om du inte redan har uvföljer du installationsanvisningarna.
En databas på SQL Server, Azure SQL Database eller SQL Database i Fabric med AdventureWorks2025 exempelschemat och en giltig anslutningssträng.

Installera förutsättningar för operativsystemet

Installera operativsystemsspecifika engångsförutsättningar. Windows-användare kan hoppa över detta steg. För fullständiga plattformsdetaljer, se Installera mssql-python.

apk add libtool krb5-libs krb5-dev libstdc++

apt-get install -y libltdl7 libkrb5-3 libgssapi-krb5-2

dnf install -y libtool-ltdl krb5-libs

zypper install -y libltdl7 libkrb5-3 libgssapi-krb5-2

zypper install -y libltdl7

brew install openssl

Skapa en SQL-databas

Skapa eller koppla till en SQL-databas på en av följande plattformar:

Skapa en SQL-databas på några minuter med hjälp av Azure-portalen

Skapa ett nytt projekt

Öppna en kommandotolk i utvecklingskatalogen. Om du inte har någon, skapa en ny katalog, till exempel python eller scripts. Undvik mappar på din OneDrive, eftersom synkronisering kan störa hanteringen av din virtuella miljö.

Skapa ett nytt projekt med uv.

uv init rapid-prototyping-qs
cd rapid-prototyping-qs

Lägga till beroenden

Installera paketen mssql-python, streamlitoch python-dotenv i samma katalog.

uv add mssql-python python-dotenv streamlit

Öppna Visual Studio Code

Kör följande kommando i samma katalog.

code .

Uppdatera pyproject.toml

pyproject.toml Öppna filen i redigeringsprogrammet. Denna fil innehåller metadata för ditt projekt.

Uppdatera värdet description .

description = "A quick example of rapid prototyping using the mssql-python driver and Streamlit."

Spara och stäng filen.

Uppdatera main.py

Öppna filen med namnet main.py. Det bör likna det här exemplet.

def main():
    print("Hello from rapid-prototyping-qs!")

if __name__ == "__main__":
    main()

Högst upp i filen, lägg till följande importer före raden med def main().

Tips/Råd

Om Visual Studio Code har problem med att lösa paket måste du uppdatera tolken så att den använder den virtuella miljön.
```
from os import getenv
from dotenv import load_dotenv
from mssql_python import connect, Connection
import pandas as pd
import streamlit as st
```

Mellan importerna och raden med def main()lägger du till följande kod.

def page_load() -> None:
    st.set_page_config(
        page_title="View Data",
        page_icon=":bar_chart:",
        layout="wide",
        initial_sidebar_state="expanded"
    )

    st.title("AdventureWorksLT Customer Order History")

    SQL_QUERY = """
    SELECT c.*
    FROM SalesLT.Customer AS c
    INNER JOIN SalesLT.SalesOrderHeader AS soh
        ON c.CustomerID = soh.CustomerID;
    """

    df = load_data(SQL_QUERY)

    event = st.dataframe(
        df,
        use_container_width=True,
        hide_index=True,
        on_select="rerun",
        selection_mode="single-row"
    )

    customer = event.selection.rows

    SPEND_QUERY_ALL = """
    SELECT
        soh.OrderDate,
        SUM(sod.OrderQty),
        SUM(sod.OrderQty * sod.UnitPrice) AS spend,
        pc.Name AS ProductCategory
    FROM SalesLT.SalesOrderDetail AS sod
    INNER JOIN SalesLT.SalesOrderHeader AS soh
        ON sod.SalesOrderID = soh.SalesOrderID
    INNER JOIN SalesLT.Product AS p
        ON sod.ProductID = p.ProductID
    INNER JOIN SalesLT.ProductCategory AS pc
        ON p.ProductCategoryID = pc.ProductCategoryID
    GROUP BY soh.OrderDate, pc.Name
    ORDER BY soh.OrderDate, pc.Name;
    """
    SPEND_QUERY_CUSTOMER = """
    SELECT
        soh.OrderDate,
        SUM(sod.OrderQty),
        SUM(sod.OrderQty * sod.UnitPrice) AS spend,
        pc.Name AS ProductCategory
    FROM SalesLT.SalesOrderDetail AS sod
    INNER JOIN SalesLT.SalesOrderHeader AS soh
        ON sod.SalesOrderID = soh.SalesOrderID
    INNER JOIN SalesLT.Product AS p
        ON sod.ProductID = p.ProductID
    INNER JOIN SalesLT.ProductCategory AS pc
        ON p.ProductCategoryID = pc.ProductCategoryID
    WHERE soh.CustomerID = ?
    GROUP BY soh.OrderDate, pc.Name
    ORDER BY soh.OrderDate, pc.Name;
    """
    if len(customer) == 0:
        spend_df = load_data(SPEND_QUERY_ALL)
    else:
        customer_id = int(df.loc[customer, 'CustomerID'].values[0])
        spend_df = load_data(SPEND_QUERY_CUSTOMER, params=(customer_id,))

    st.write("Here's a summary of spend by product category over time:")
    st.bar_chart(spend_df.set_index('ProductCategory')['spend'], use_container_width=True)

    if len(customer) > 0:
        st.write(f"Displaying orders for Customer ID: {df.loc[customer, 'CustomerID'].values[0]}")
        customer_id = int(df.loc[customer, 'CustomerID'].values[0])
        SQL_QUERY = """
        SELECT *
        FROM SalesLT.SalesOrderHeader AS soh
        WHERE soh.CustomerID = ?;
        """
        st.dataframe(load_data(SQL_QUERY, params=(customer_id,)), hide_index=True, use_container_width=True)
        SQL_QUERY = """
        SELECT sod.*
        FROM SalesLT.SalesOrderHeader AS soh
        INNER JOIN SalesLT.SalesOrderDetail AS sod
            ON soh.SalesOrderID = sod.SalesOrderID
        WHERE soh.CustomerID = ?;
        """
        st.dataframe(load_data(SQL_QUERY, params=(customer_id,)), hide_index=True, use_container_width=True)

Mellan importerna och def page_load() -> None:lägger du till den här koden.

_connection = None

def get_connection() -> Connection:
    global _connection
    if not _connection:
        load_dotenv()
        _connection = connect(getenv("SQL_CONNECTION_STRING"))
    return _connection

@st.cache_data
def load_data(SQL_QUERY, params=None) -> pd.DataFrame:
    data = pd.read_sql_query(SQL_QUERY, get_connection(), params=params)
    return data

Hitta den här koden.

def main():
    print("Hello from rapid-prototyping-qs!")

Ersätt den med den här koden.

def main() -> None:
    page_load()
    if _connection:
        _connection.close()

Spara och stäng main.py.

Spara anslutningssträngen

.gitignore Öppna filen och lägg till ett undantag för .env filer. Din fil bör likna följande exempel.

# Python-generated files
__pycache__/
*.py[oc]
build/
dist/
wheels/
*.egg-info

# Virtual environments
.venv

# Connection strings and secrets
.env

Spara och stäng .gitignore.
I den aktuella katalogen skapar du en ny fil med namnet .env.
I .env-filen lägger du till en post för din anslutningssträng med namnet SQL_CONNECTION_STRING. Ersätt platshållarna med dina faktiska värden.
```
SQL_CONNECTION_STRING="Server=<server>;Database=<database>;Encrypt=yes;TrustServerCertificate=no;Authentication=ActiveDirectoryInteractive"
```
reťazec pripojenia beror på vilken typ av SQL-databas du ansluter till. För Azure SQL Database eller SQL Database in Fabric, använd ODBC-reťazec pripojenia från reťazec pripojenias-fliken och justera autentiseringstypen för ditt scenario. För mer information om reťazec pripojenia-syntax, se Connection strings för mssql-python.

Tips/Råd

På macOS fungerar både ActiveDirectoryInteractive och ActiveDirectoryDefault för Microsoft Entra-autentisering. ActiveDirectoryInteractive uppmanar dig att logga in varje gång du kör skriptet. För att undvika upprepade inloggningspromptar, logga in en gång med Azure CLI-kommandotaz login och använd ActiveDirectoryDefault. ActiveDirectoryDefault återanvänder den cachade autentiseringsuppgiften.

Använd uv run för att köra skriptet

Kör följande kommando i terminalfönstret från tidigare eller ett nytt terminalfönster som är öppet till samma katalog.
```
uv run streamlit run main.py
```
Rapporten öppnas på en ny flik i webbläsaren.
Prova rapporten för att se hur den fungerar. Om du ändrar något, spara main.py och använd alternativet uppdatera i det övre högra hörnet av webbläsarfönstret.
Om du vill dela prototypen .venv kopierar du alla filer förutom mappen till den andra datorn. Mappen .venv återskapas med den första körningen.

Feedback

Var den här sidan till hjälp?

Uppdaterades senast 2026-10-19