Inicio rápido: Creación rápida de prototipos con el controlador mssql-python para Python

En este inicio rápido, puedes Streamlit crear un informe rápidamente para poder recopilar opiniones de los usuarios con antelación. Usas el mssql-python controlador de Python para conectarte a tu base de datos y leer los datos cargados en tu informe.

El mssql-python controlador no requiere ninguna dependencia externa en máquinas Windows. El controlador instala todo lo que necesita con una sola pip instalación, lo que le permite usar la versión más reciente del controlador para nuevos scripts sin interrumpir otros scripts que no tenga tiempo para actualizar y probar.

Documentación de mssql-python | Código fuente de mssql-python | Paquete (PyPI) | uv

Prerrequisitos

Python 3.10 o posterior.
Si aún no tiene Python, instale el entorno de ejecución de Python y el administrador de paquetes pip desde python.org.
¿No quieres utilizar tu propio entorno? Sigue las instrucciones de Contenedores y desarrollo local para crear un devcontainer reproducible o un entorno de GitHub Codespaces.
Visual Studio Code con las siguientes extensiones:
- Extensión de Python para Visual Studio Code
Interfaz de Azure Command-Line (CLI) para la autenticación sin contraseña en macOS y Linux.
Si aún no tiene uv, siga las instrucciones de instalación.
Una base de datos en SQL Server, Azure SQL Database o SQL Database en Fabric con el AdventureWorks2025 esquema de ejemplo y una cadena de conexión válida.

Requisitos previos para instalar el sistema operativo

Instala los requisitos previos específicos del sistema operativo, que solo hay que instalar una vez. Los usuarios de Windows pueden saltarse este paso. Para detalles completos sobre la plataforma, véase 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

Creación de una base de datos SQL

Crea o conéctate a una base de datos SQL en una de las siguientes plataformas:

Creación de una base de datos SQL en cuestión de minutos mediante Azure Portal

Creación del proyecto y ejecución del código

Creación de un nuevo proyecto
Agregar dependencias
Inicio de Visual Studio Code
Actualizar pyproject.toml
Actualizar main.py
Guardar la cadena de conexión
Usa uv run para ejecutar el script

Creación de un nuevo proyecto

Abre una ventana de comandos en tu directorio de desarrollo. Si no tienes uno, crea un nuevo directorio, como python o scripts. Evita las carpetas en tu OneDrive, ya que la sincronización puede interferir en la gestión de tu entorno virtual.

Cree un proyecto con uv.

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

Agregar dependencias

En el mismo directorio, instale los mssql-pythonpaquetes , streamlity python-dotenv .

uv add mssql-python python-dotenv streamlit

Iniciar Visual Studio Code

En el mismo directorio, ejecute el siguiente comando.

code .

Actualizar pyproject.toml

Abra el archivo pyproject.toml en un editor. Este archivo contiene los metadatos de tu proyecto.

Actualiza el valor description.

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

Guarde y cierre el archivo.

Actualizar main.py

Abra el archivo denominado main.py. Debe ser similar a este ejemplo.

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

if __name__ == "__main__":
    main()

En la parte superior del archivo, añade las siguientes importaciones antes de la línea con def main().

Sugerencia

Si Visual Studio Code tiene problemas para resolver los paquetes, debe actualizar el intérprete para usar el entorno 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 las importaciones y la línea con def main(), agregue el código siguiente.

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 las importaciones y def page_load() -> None:, agregue 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

Busque este código.

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

Reemplácelo por este código.

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

Guarde y cierre main.py.

Guardar la cadena de conexión

Abra el .gitignore archivo y agregue una exclusión para .env los archivos. Tu archivo debería ser similar al siguiente ejemplo.

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

# Virtual environments
.venv

# Connection strings and secrets
.env

Guarde y cierre .gitignore.
En el directorio actual, cree un nuevo archivo denominado .env.
En el .env archivo, agregue una entrada para la cadena de conexión denominada SQL_CONNECTION_STRING. Sustituya los marcadores de posición por sus valores reales.
```
SQL_CONNECTION_STRING="Server=<server>;Database=<database>;Encrypt=yes;TrustServerCertificate=no;Authentication=ActiveDirectoryInteractive"
```
La cadena de conexión depende del tipo de base de datos SQL a la que te conectes. Para Azure SQL Database o base de datos SQL en Fabric, usa la cadena de conexión ODBC de la pestaña de cadenas de conexión y ajusta el tipo de autenticación para tu escenario. Para más información sobre la sintaxis de cadena de conexión, véase Connection strings for mssql-python.

Sugerencia

En macOS, tanto ActiveDirectoryInteractive como ActiveDirectoryDefault funcionan para la autenticación de Microsoft Entra. ActiveDirectoryInteractive le pide que inicie sesión cada vez que ejecute el script. Para evitar que se repitan los prompts de inicio de sesión, inicia sesión una vez con el comando CLI de Azureaz login y utiliza ActiveDirectoryDefault. ActiveDirectoryDefault Reutiliza la credencial almacenada en caché.

Usa uv run para ejecutar el script

En la ventana de terminal desde antes o una nueva ventana de terminal abierta en el mismo directorio, ejecute el siguiente comando.
```
uv run streamlit run main.py
```
El informe se abre en una nueva pestaña del explorador web.
Pruebe su informe para ver cómo funciona. Si cambia algo, guarde main.py y use la opción volver a cargar en la esquina superior derecha de la ventana del explorador.
Para compartir el prototipo, copie todos los archivos excepto la .venv carpeta en la otra máquina. La .venv carpeta se vuelve a crear con la primera ejecución.

Comentarios

¿Le ha resultado útil esta página?

Se actualizó por última vez el 2026-10-19