Guia de início rápido: prototipagem rápida com o driver mssql-python para Python

Neste quickstart, utiliza Streamlit para criar um relatório rapidamente, para recolher feedback dos utilizadores cedo. Utiliza o mssql-python controlador do Python para se ligar à sua base de dados e ler os dados carregados no seu relatório.

O mssql-python driver não requer nenhuma dependência externa em máquinas Windows. O driver instala tudo o que precisa com uma única pip instalação, permitindo que você use a versão mais recente do driver para novos scripts sem quebrar outros scripts que você não tem tempo para atualizar e testar.

Documentação | Código-fonte | Pacote (PyPI) | UV

Pré-requisitos

Python 3.10 ou posterior.
Se ainda não tens o Python, instala o runtime do Python e o gestor de pacotes pip a partir de python.org.
Não quer usar o seu próprio ambiente? Consulte Container and local development para criar um ambiente devcontainer reproduzível ou um ambiente do GitHub Codespaces.
Visual Studio Code com as seguintes extensões:
- Extensão Python para Visual Studio Code
Azure Command-Line Interface (CLI) para autenticação sem palavra-passe no macOS e Linux.
Se ainda não tiver uv, siga as instruções de instalação.
Um banco de dados no SQL Server, Banco de Dados SQL do Azure ou Banco de Dados SQL no Fabric com o AdventureWorks2025 esquema de exemplo e uma cadeia de conexão válida.

Pré-requisitos para instalar o sistema operativo

Instale pré-requisitos que devem ser instalados uma única vez específicos do sistema operacional. Os utilizadores do Windows podem saltar este passo. Para detalhes completos da plataforma, consulte Instalar 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

Criar um banco de dados SQL

Criar ou ligar-se a uma base de dados SQL numa das seguintes plataformas:

Criar um banco de dados SQL em minutos usando o portal do Azure

Criar um novo projeto

Abra um prompt de comando no diretório de desenvolvimento. Se não tiver um, crie um novo diretório, como python ou scripts. Evite pastas no seu OneDrive, pois a sincronização pode interferir na gestão do seu ambiente virtual.

Crie um novo projeto com uv.

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

Adicionar dependências

No mesmo diretório, instale os pacotes mssql-python, streamlit e python-dotenv.

uv add mssql-python python-dotenv streamlit

Abra o Visual Studio Code.

No mesmo diretório, execute o seguinte comando.

code .

Atualizar pyproject.toml

Abra o pyproject.toml arquivo no editor. Este ficheiro contém os metadados do seu projeto.

Atualize o valor description.

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

Salve e feche o arquivo.

Atualizar main.py

Abra o arquivo chamado main.py. Deve ser semelhante a este exemplo.

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

if __name__ == "__main__":
    main()

No topo do ficheiro, adicione as seguintes importações antes da linha com def main().

Sugestão

Se o Visual Studio Code estiver tendo problemas para resolver pacotes, você precisará atualizar o intérprete para usar o ambiente virtual.
```
from os import getenv
from dotenv import load_dotenv
from mssql_python import connect, Connection
import pandas as pd
import streamlit as st
```

Entre as importações e a linha com def main(), adicione o código a seguir.

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)

Entre as importações e def page_load() -> None:, adicione este código.

_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

Encontre este código.

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

Substitua-o por este código.

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

Salve e feche main.py.

Salvar a cadeia de conexão

Abra o .gitignore arquivo e adicione uma exclusão para .env arquivos. O seu ficheiro deve ser semelhante ao exemplo seguinte.

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

# Virtual environments
.venv

# Connection strings and secrets
.env

Salve e feche .gitignore.
No diretório atual, crie um novo arquivo chamado .env.
Dentro do .env arquivo, adicione uma entrada para sua cadeia de conexão chamada SQL_CONNECTION_STRING. Substitua os espaços reservados pelos seus valores reais.
```
SQL_CONNECTION_STRING="Server=<server>;Database=<database>;Encrypt=yes;TrustServerCertificate=no;Authentication=ActiveDirectoryInteractive"
```
A cadeia de ligação depende do tipo de base de dados SQL a que está a estabelecer ligação. Para Base de Dados SQL do Azure ou base de dados SQL no Fabric, use a cadeia de ligação ODBC do separador cadeia de ligaçãos e ajuste o tipo de autenticação para o seu cenário. Para mais informações sobre a sintaxe das cadeias de ligação, veja Connection strings for mssql-python.

Sugestão

No macOS, tanto ActiveDirectoryInteractive como ActiveDirectoryDefault funcionam para a autenticação do Microsoft Entra. ActiveDirectoryInteractive Solicita-te para iniciar sessão sempre que executas o script. Para evitar repetidos prompts de início de sessão, inicie sessão uma vez com o comando CLI do Azureaz login e use ActiveDirectoryDefault. ActiveDirectoryDefault reutiliza a credencial em cache.

Use uv run para executar o script

Na janela do terminal anterior ou em uma nova janela do terminal aberta no mesmo diretório, execute o seguinte comando.
```
uv run streamlit run main.py
```
O relatório é aberto em uma nova guia no navegador da Web.
Experimente o seu relatório para ver como funciona. Se você alterar alguma coisa, salve main.py e use a opção de recarga no canto superior direito da janela do navegador.
Para compartilhar seu protótipo, copie todos os arquivos, exceto a .venv pasta, para a outra máquina. A .venv pasta é recriada com a primeira execução.

Comentários

Esta página foi útil?

Última atualização a 2026-10-19