Início Rápido: Criação rápida de protótipos com o driver mssql-python para Python

Neste início rápido, você usa Streamlit para criar um relatório rapidamente, para coletar feedback dos usuários cedo. Você usa o mssql-python driver do Python para se conectar ao seu banco de dados e ler os dados carregados no seu relatório.

O mssql-python driver não requer nenhuma dependência externa em computadores 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 do mssql-pythonCódigo-fonte mssql-pythonPacote (PyPI)uv

Pré-requisitos

Python 3.10 ou posterior.
Se você ainda não tiver o Python, instale o runtime do Python e o gerenciador de pacotes pip de python.org.
Não quer usar seu próprio ambiente? Siga Contêiner e desenvolvimento local para criar um devcontainer reproduzível ou um ambiente de Codespaces no GitHub.
Visual Studio Code com as seguintes extensões:
- Extensão do Python para Visual Studio Code
CLI (Interface Command-Line) do Azure para autenticação sem senha no macOS e linux.
Se você ainda não tiver uv, siga as instruções de instalação.
Um banco de dados no SQL Server, no Banco de Dados SQL do Azure ou no 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 operacional

Instale pré-requisitos específicos do sistema operacional uma vez. Usuários do Windows podem pular essa etapa. Para detalhes completos da plataforma, veja 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

Crie ou conecte-se a um banco de dados SQL em uma das seguintes plataformas:

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

Criar o projeto e executar o código

Criar um novo projeto
Adicionar dependências
Iniciar Visual Studio Code
Atualizar pyproject.toml
Atualizar main.py
Salvar a cadeia de conexão
Use o comando uv run para executar o script

Criar um novo projeto

Abra um prompt de comando no diretório de desenvolvimento. Se você não tiver um, crie um novo diretório, como python ou scripts. Evite pastas no seu OneDrive, pois a sincronização pode interferir no gerenciamento 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

Iniciar o Visual Studio Code

No mesmo diretório, execute o comando a seguir.

code .

Atualizar pyproject.toml

Abra o arquivo pyproject.toml no editor. Este arquivo 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 arquivo, adicione as seguintes importações antes da linha com def main().

Dica

Se o Visual Studio Code estiver tendo problemas para resolver pacotes, você precisará atualizar o interpretador 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

Localize este código.

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

Substitua-o por esse código.

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

Salvar e fechar main.py.

Salvar a cadeia de conexão

Abra o .gitignore arquivo e adicione uma exclusão para .env arquivos. Seu arquivo deve ser semelhante ao exemplo a seguir.

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

# Virtual environments
.venv

# Connection strings and secrets
.env

Salvar e fechar .gitignore.
No diretório atual, crie um novo arquivo chamado .env.
No arquivo .env, adicione uma entrada para sua string de conexão chamada SQL_CONNECTION_STRING. Substitua os marcadores de posição pelos seus valores reais.
```
SQL_CONNECTION_STRING="Server=<server>;Database=<database>;Encrypt=yes;TrustServerCertificate=no;Authentication=ActiveDirectoryInteractive"
```
A cadeia de conexão depende do tipo de banco de dados SQL ao qual você está se conectando. Para Banco de Dados SQL do Azure ou SQL Database no Fabric, use a cadeia de conexão ODBC da aba de strings de conexão e ajuste o tipo de autenticação para o seu cenário. Para mais informações sobre a sintaxe das cadeia de conexão, veja Connection strings for mssql-python.

Dica

No macOS, tanto ActiveDirectoryInteractive quanto ActiveDirectoryDefault funcionam para autenticação do Microsoft Entra. ActiveDirectoryInteractive solicita que você faça login toda vez que executar o script. Para evitar prompts repetidos de login, faça login uma vez com o comando CLI do Azureaz login e use ActiveDirectoryDefault. ActiveDirectoryDefault reutiliza a credencial em cache.

Use o comando uv run para executar o script

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

Comentários

Esta página foi útil?

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