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.10 nebo novější

  • Pokud ještě nemáte Python, nainstalujte Python runtime a správce balíčků pip z python.org.

  • Nechcete používat vlastní prostředí? Postupujte podle Kontejner a místní vývoj a vytvořte reprodukovatelné vývojové prostředí devcontainer nebo 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. Uživatelé Windows mohou tento krok přeskočit. Pro úplné podrobnosti o platformě viz Instalace mssql-python.

apk add libtool krb5-libs krb5-dev

Vytvoření databáze SQL

Vytvořte nebo se připojte k SQL databázi na jedné z následujících platforem:

Vytvoření projektu a spuštění kódu

Vytvoření nového projektu

  1. Otevřete příkazový řádek ve vývojovém adresáři. Pokud žádný nemáte, vytvořte nový adresář, například python nebo scripts. Vyhněte se složkám na OneDrive, protože synchronizace může narušit správu virtuálního prostředí.

  2. 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

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

  2. Aktualizujte popis, aby byl popisnější.

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

  3. Uložte a zavřete soubor.

Aktualizace main.py

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

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

if __name__ == "__main__":
    main()

  2. Na vrchol souboru přidejte následující importy před řá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

  3. 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)

  4. 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

  5. Vyhledejte tento kód.

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

  6. Nahraďte ho tímto kódem.

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

  7. Uložte a zavřete main.py.

Uložte řetězec připojení

  1. .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

  2. V aktuálním adresáři vytvořte nový soubor s názvem .env.

  3. .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. Abychom se vyhnuli opakovaným výzvám k přihlášení, přihlaste se jednou přes Azure CLI spuštěním az login, poté použijte ActiveDirectoryDefault, které znovu použije cacheované přihlašovací údaje.

  1. 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

  2. Vaše zpráva se otevírá na nové kartě ve webovém prohlížeči.

  3. 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.

  4. 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ší kroky

Použijte tyto články k dalšímu budování:

Rychlý start: Opakovatelná nasazení

  • Last updated on