Início Rápido: Conectar-se a um banco de dados SQL no Fabric com o Microsoft Python Driver for SQL Server

Neste início rápido, você usará Streamlit para criar rapidamente um relatório, permitindo que você reúna rapidamente os comentários do usuário para garantir que você esteja no caminho certo. Você usa o mssql-python driver do Python para se conectar ao banco de dados SQL no Fabric e ler os dados carregados em 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 mssql-python | Código-fonte mssql-python | Pacote (PyPi) | UV

Pré-requisitos

• Carregue dados de exemplo do AdventureWorks em seu banco de dados SQL.

• Python 3

  • Se você ainda não tiver o Python, instale o runtime do Python e o gerenciador de pacotes PyPI (Python Package Index) do python.org.

  • Prefere não utilizar o seu próprio ambiente? Abra como um devcontainer usando codespaces do GitHub.

    

• Visual Studio Code com as seguintes extensões:

  • Extensão do Python para Visual Studio Code

  • (Opcional) Repositórios do Azure

• (Opcional) CLI (Interface de Linha de Comando do Azure)

• Se você ainda não tiver uv, instale uv seguindo as instruções de https://docs.astral.sh/uv/getting-started/installation/.

• Instale pré-requisitos específicos do sistema operacional uma vez.

  • Alpino
  • Debian/Ubuntu
  • RHEL
  • SUSE
  • openSUSE
  • macOS

  apk add libtool krb5-libs krb5-dev
  

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

1. Abra um prompt de comando no diretório de desenvolvimento. Se você não tiver um, crie um novo diretório chamado python, scriptsetc. Evite pastas em seu OneDrive, a sincronização pode interferir no gerenciamento do seu ambiente virtual.

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

1. O pyproject.toml contém os metadados do projeto. Abra o arquivo em seu editor favorito.

2. Atualize a descrição para ser mais descritiva.

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

3. Salve e feche o arquivo.

Atualizar main.py

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

   def main():
    print("Hello from rapid-protyping-qs!")
   
    if __name__ == "__main__":
      main()
   

2. Na parte superior do arquivo, adicione as seguintes importações acima 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
   

3. 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] c inner join SalesLT.SalesOrderHeader soh on c.CustomerId = soh.CustomerId;"""
   
      df = load_data(SQL_QUERY)
   
      event = st.dataframe(
          df,
          width='stretch',
          hide_index=True,
          on_select="rerun",
          selection_mode="single-row"
      )
   
      customer = event.selection.rows
   
      if len(customer) == 0:
          SQL_QUERY = """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;"""
      else:
          SQL_QUERY = f"""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 = {df.loc    [customer, 'CustomerID'].values[0]} GROUP BY soh.OrderDate, pc.Name ORDER BY soh.OrderDate, pc.Name;"""
   
      st.write("Here's a summary of spend by product category over time:")
      st.bar_chart(load_data(SQL_QUERY).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]}")
          SQL_QUERY = f"""SELECT * FROM [SalesLT].[SalesOrderHeader] soh  WHERE soh.CustomerID = {df.loc[customer, 'CustomerID'].values[0]};"""
          st.dataframe(load_data(SQL_QUERY), hide_index=True, width='stretch')
          SQL_QUERY = f"""SELECT sod.* FROM [SalesLT].[SalesOrderHeader] soh INNER JOIN SalesLT.SalesOrderDetail sod on soh.SalesOrderId = sod.SalesOrderId WHERE CustomerID = {df.loc[customer, 'CustomerID'].values[0]};"""
          st.dataframe(load_data(SQL_QUERY), hide_index=True, width='stretch')
   

4. 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) -> pd.DataFrame:
       data = pd.read_sql_query(SQL_QUERY, get_connection())
       return data
   

5. Localize este código.

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

6. Substitua-o por esse código.

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

7. Salvar e fechar main.py.

Salvar a cadeia de conexão

1. Abra o .gitignore arquivo e adicione uma exclusão para .env arquivos. Seu arquivo deve ser semelhante a este exemplo. Salve-o e feche-o quando terminar.

   # Python-generated files
   __pycache__/
   *.py[oc]
   build/
   dist/
   wheels/
   *.egg-info
   
   # Virtual environments
   .venv
   
   # Connection strings and secrets
   .env
   

2. No diretório atual, crie um novo arquivo chamado .env.

3. No arquivo .env, adicione uma entrada para sua string de conexão chamada SQL_CONNECTION_STRING. Substitua o exemplo aqui pelo valor real da cadeia de conexão.

   SQL_CONNECTION_STRING="Server=<server_name>;Database={<database_name>};Encrypt=yes;TrustServerCertificate=no;Authentication=ActiveDirectoryInteractive"
   

Use o comando uv run para executar o script

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

2. Seu relatório é aberto em uma nova guia no navegador da Web.

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

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

Próxima etapa

Visite o repositório GitHub do mssql-python driver para obter mais exemplos, contribuir com ideias ou relatar problemas.