Rychlý start: Rychlé vytváření prototypů pomocí ovladače mssql-python pro Python

V tomto rychlém startu použijete Streamlit k rychlému vytvoření sestavy, která vám umožní rychle shromáždit zpětnou vazbu uživatelů, abyste měli jistotu, že jste na správné cestě. Ovladač pro Python slouží mssql-python k připojení k databázi a čtení dat načtených do sestavy.

Ovladač mssql-python nevyžaduje žádné externí závislosti na počítačích s Windows. Ovladač nainstaluje všechno, co potřebuje, s jednou pip instalací, což vám umožní používat nejnovější verzi ovladače pro nové skripty bez přerušení jiných skriptů, které nemáte čas upgradovat a testovat.

Dokumentace mssql-python, zdrojový kód mssql-python, Balíček (PyPI) uv

Požadavky

Python 3
- Pokud ještě nemáte Python, nainstalujte Python runtime a správce balíčků pip z python.org.
- Nechcete používat vlastní prostředí? Otevřete jako devcontainer pomocí GitHub Codespaces.
Visual Studio Code s následujícími rozšířeními:
- Rozšíření Pythonu pro Visual Studio Code
Azure Command-Line Interface (CLI) pro ověřování bez hesla v systému macOS a Linux.
Pokud ještě uvnemáte, postupujte podle pokynů k instalaci.
Databáze na SQL Serveru, Azure SQL Database nebo SQL databáze v Fabric s ukázkovým AdventureWorks2025 schématem a platným připojovacím řetězcem.

Nainstalujte požadavky specifické pro jednorázový operační systém.

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

Vytvoření databáze SQL

Tento rychlý start vyžaduje schéma AdventureWorks2025 Lightweight na Microsoft SQL Serveru, SQL databázi v Fabric nebo Azure SQL Database.

Vytvoření databáze SQL v řádu minut pomocí webu Azure Portal

Vytvoření nového projektu

Otevřete příkazový řádek ve vývojovém adresáři. Pokud ho nemáte, vytvořte nový adresář s názvem python, scriptsatd. Vyhněte se složkám na OneDrivu, synchronizace může narušit správu vašeho virtuálního prostředí.

Vytvořte nový projekt pomocí uvpříkazu .

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

Přidejte závislosti

Ve stejném adresáři nainstalujte balíčky mssql-python, streamlit a python-dotenv.

uv add mssql-python python-dotenv streamlit

Spusťte Visual Studio Code

Ve stejném adresáři spusťte následující příkaz.

code .

Aktualizace pyproject.toml

Soubor pyproject.toml obsahuje metadata pro váš projekt. Otevřete soubor v oblíbeném editoru.

Aktualizujte popis, aby byl popisnější.

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

Uložte a zavřete soubor.

Aktualizace main.py

Otevřete soubor s názvem main.py. Měl by se podobat tomuto příkladu.

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

 if __name__ == "__main__":
   main()

V horní části souboru přidejte následující importy nad řádek s def main().

Návod

Pokud má Visual Studio Code potíže s řešením balíčků, musíte interpreta aktualizovat tak, aby používal virtuální prostředí.
```
from os import getenv
from dotenv import load_dotenv
from mssql_python import connect, Connection
import pandas as pd
import streamlit as st
```

Mezi importy a řádek s def main(), přidejte následující kód.

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)

Mezi importy a def page_load() -> None:přidejte tento kód.

_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

Vyhledejte tento kód.

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

Nahraďte ho tímto kódem.

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

Uložte a zavřete main.py.

Uložte řetězec připojení

.gitignore Otevřete soubor a přidejte vyloučení souborů.env. Soubor by měl být podobný tomuto příkladu. Až budete hotovi, nezapomeňte ho uložit a zavřít.
```
# Python-generated files
__pycache__/
*.py[oc]
build/
dist/
wheels/
*.egg-info

# Virtual environments
.venv

# Connection strings and secrets
.env
```
V aktuálním adresáři vytvořte nový soubor s názvem .env.
.env V souboru přidejte položku pro připojovací řetězec s názvem SQL_CONNECTION_STRING. Příklad zde nahraďte skutečnou hodnotou připojovacího řetězce.
```
SQL_CONNECTION_STRING="Server=<server_name>;Database=<database_name>;Encrypt=yes;TrustServerCertificate=no;Authentication=ActiveDirectoryInteractive"
```
Návod

Připojovací řetězec použitý zde do značné míry závisí na typu databáze SQL, ke které se připojujete. Pokud se připojujete k Azure SQL Database nebo k SQL databázi ve Fabric, použijte připojovací řetězec ODBC z karty Připojovací řetězce. Možná budete muset upravit typ ověřování v závislosti na vašem scénáři. Další informace o připojovacích řetězcích a jejich syntaxi najdete v referenčních informacích k syntaxi připojovacího řetězce.

Použijte 'uv run' ke spuštění skriptu

Návod

V systému macOS funguje ověřování pomocí Microsoft Entra jak s ActiveDirectoryInteractive, tak s ActiveDirectoryDefault. ActiveDirectoryInteractive vás vyzve k přihlášení při každém spuštění skriptu. Pokud se chcete vyhnout opakovaným výzvám k přihlášení, přihlaste se jednou přes Azure CLI spuštěním az logina pak použijte ActiveDirectoryDefaultpříkaz , který znovu použije přihlašovací údaje uložené v mezipaměti.

V okně terminálu před nebo v novém okně terminálu, které se otevře ve stejném adresáři, spusťte následující příkaz.
```
 uv run streamlit run main.py
```
Vaše zpráva se otevírá na nové kartě ve webovém prohlížeči.
Vyzkoušejte sestavu a podívejte se, jak funguje. Pokud něco změníte, uložte main.py a použijte možnost opětovného načtení v pravém horním rohu okna prohlížeče.
Pokud chcete sdílet prototyp, zkopírujte všechny soubory s výjimkou .venv složky na druhý počítač. Složka .venv se znovu vytvoří při prvním spuštění.

Další krok

Další příklady najdete v mssql-python úložišti GitHubu ovladače, kde můžete přispívat nápady nebo hlásit problémy.

Ovladač mssql-python na GitHubu

Váš názor

Byla tato stránka užitečná?

Last updated on 2026-03-18