Szybki start: szybkie tworzenie prototypów za pomocą sterownika mssql-python dla języka Python

W tym przewodniku szybkiego startu utworzysz Streamlit raport, aby szybko zebrać opinie użytkowników, co pozwoli upewnić się, że zmierzasz we właściwym kierunku. Używasz sterownika mssql-python Pythona, aby połączyć się z bazą danych i odczytywać dane załadowane do raportu.

Sterownik mssql-python nie wymaga żadnych zależności zewnętrznych na maszynach z systemem Windows. Sterownik instaluje wszystko, czego potrzebuje w ramach pojedynczej pip instalacji, co pozwala na użycie najnowszej wersji sterownika dla nowych skryptów bez przerywania innych skryptów, których nie masz czasu na uaktualnienie i przetestowanie.

Dokumentacja mssql-python Kod źródłowy mssql-python Pakiet (PyPI) uv

Wymagania wstępne

Python 3
- Jeśli nie masz jeszcze języka Python, zainstaluj środowisko uruchomieniowe języka Python i menedżera pakietów z python.org.
- Nie chcesz używać własnego środowiska? Otwórz jako devcontainer przy użyciu usługi GitHub Codespaces.
Visual Studio Code z następującymi rozszerzeniami:
- Rozszerzenie języka Python dla programu Visual Studio Code
Interfejs azure Command-Line (CLI) na potrzeby uwierzytelniania bez hasła w systemach macOS i Linux.
Jeśli jeszcze nie masz uvprogramu , postępuj zgodnie z instrukcjami instalacji.
Baza danych w programie SQL Server, usłudze Azure SQL Database lub bazie danych SQL w usłudze Fabric z przykładowym AdventureWorks2025 schematem i prawidłowymi parametrami połączenia.

Zainstaluj jednorazowe wymagania wstępne dotyczące systemu operacyjnego.

apk add libtool krb5-libs krb5-dev

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

Tworzenie bazy danych SQL

Ten szybki start wymaga schematu AdventureWorks2025 Lightweight w Microsoft SQL Server, bazie danych SQL w Fabric lub Azure SQL Database.

Tworzenie bazy danych SQL w ciągu kilku minut przy użyciu witryny Azure Portal

Tworzenie projektu i uruchamianie kodu

Tworzenie nowego projektu
Dodawanie zależności
Uruchamianie programu Visual Studio Code
Aktualizowanie pliku pyproject.toml
Aktualizowanie main.py
Zapisywanie parametrów połączenia
Użyj narzędzia uv run, aby wykonać skrypt

Tworzenie nowego projektu

Otwórz wiersz polecenia w katalogu deweloperów. Jeśli go nie masz, utwórz nowy katalog o nazwie python, scriptsitp. Unikaj folderów w usłudze OneDrive, synchronizacja może zakłócać zarządzanie środowiskiem wirtualnym.

Utwórz nowy projekt za pomocą polecenia uv.

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

Dodawanie zależności

W tym samym katalogu zainstaluj pakiety mssql-python, streamlit i python-dotenv.

uv add mssql-python python-dotenv streamlit

Uruchom program Visual Studio Code.

W tym samym katalogu uruchom następujące polecenie.

code .

Aktualizowanie pliku pyproject.toml

Plik pyproject.toml zawiera metadane projektu. Otwórz plik w ulubionym edytorze.

Zaktualizuj opis, aby był bardziej opisowy.

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

Zapisz i zamknij plik.

Aktualizowanie main.py

Otwórz plik o nazwie main.py. Powinien być podobny do tego przykładu.

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

 if __name__ == "__main__":
   main()

W górnej części pliku dodaj następujące importy powyżej wiersza za pomocą polecenia def main().

Wskazówka

Jeśli program Visual Studio Code ma problemy z rozwiązaniem problemów z pakietami, należy zaktualizować interpreter, aby używał środowiska wirtualnego.
```
from os import getenv
from dotenv import load_dotenv
from mssql_python import connect, Connection
import pandas as pd
import streamlit as st
```

Między importami a wierszem z def main() dodaj następujący 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] c inner join SalesLT.SalesOrderHeader 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 sod inner join SalesLT.SalesOrderHeader soh on sod.salesorderid = soh.salesorderid inner join SalesLT.Product p on sod.productid = p.productid inner join SalesLT.ProductCategory 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 sod inner join SalesLT.SalesOrderHeader soh on sod.salesorderid = soh.salesorderid inner join SalesLT.Product p on sod.productid = p.productid inner join SalesLT.ProductCategory 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] 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] soh INNER JOIN SalesLT.SalesOrderDetail sod on soh.SalesOrderId = sod.SalesOrderId WHERE CustomerID = ?;"""
       st.dataframe(load_data(SQL_QUERY, params=(customer_id,)), hide_index=True, use_container_width=True)

Między importami i def page_load() -> None:dodaj ten kod.

_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

Znajdź ten kod.

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

Zastąp go tym kodem.

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

Zapisz i zamknij plik main.py.

Zapisz łańcuch połączeniowy

.gitignore Otwórz plik i dodaj wykluczenie dla .env plików. Plik powinien być podobny do tego przykładu. Pamiętaj, aby zapisać i zamknąć go po zakończeniu.
```
# Python-generated files
__pycache__/
*.py[oc]
build/
dist/
wheels/
*.egg-info

# Virtual environments
.venv

# Connection strings and secrets
.env
```
W bieżącym katalogu utwórz nowy plik o nazwie .env.
W pliku .env dodaj wpis dla łańcucha połączenia o nazwie SQL_CONNECTION_STRING. Zastąp przykład wartością rzeczywistych parametrów połączenia.
```
SQL_CONNECTION_STRING="Server=<server_name>;Database=<database_name>;Encrypt=yes;TrustServerCertificate=no;Authentication=ActiveDirectoryInteractive"
```
Wskazówka

Parametry połączenia używane w tym miejscu w dużej mierze zależą od typu bazy danych SQL, z którą nawiązujesz połączenie. Jeśli nawiązujesz połączenie z usługą Azure SQL Database lub bazą danych SQL w sieci szkieletowej, użyj parametrów połączenia ODBC z karty parametry połączenia. W zależności od scenariusza może być konieczne dostosowanie typu uwierzytelniania. Aby uzyskać więcej informacji na temat parametrów połączenia i ich składni, zobacz dokumentację składni parametrów połączenia.

Użyj narzędzia uv run, aby wykonać skrypt

Wskazówka

Zarówno ActiveDirectoryInteractive, jak i ActiveDirectoryDefault działają na systemie macOS do uwierzytelniania Microsoft Entra. ActiveDirectoryInteractive monituje o zalogowanie się przy każdym uruchomieniu skryptu. Aby uniknąć powtarzających się monitów logowania, zaloguj się raz za pośrednictwem Azure CLI, uruchamiając az login, a następnie użyj ActiveDirectoryDefault, który wykorzystuje buforowane poświadczenie.

W wcześniejszym oknie terminalu lub w nowym oknie terminalu, które jest otwarte w tym samym katalogu, wykonaj następujące polecenie.
```
 uv run streamlit run main.py
```
Raport zostanie otwarty na nowej karcie w przeglądarce internetowej.
Wypróbuj raport, aby zobaczyć, jak to działa. Jeśli coś zmienisz, zapisz main.py i użyj opcji ponownego ładowania w prawym górnym rogu okna przeglądarki.
Aby udostępnić prototyp, skopiuj wszystkie pliki z wyjątkiem .venv folderu na inną maszynę. Folder .venv jest ponownie tworzony przy użyciu pierwszego uruchomienia.

Następny krok

Odwiedź repozytorium GitHub sterowników mssql-python, aby uzyskać więcej przykładów, wnieść pomysły lub zgłaszać problemy.

sterownik mssql-python w witrynie GitHub

Opinia

Czy ta strona była pomocna?

Last updated on 2026-03-18