Cómo cargar datos en SQL Server en un ETL (pandas)

La carga (Load) es la última etapa de un proceso ETL: después de extraer y transformar los datos, hay que guardarlos en una tabla de destino. La forma más común de cargar datos en SQL Server desde Python es escribir un DataFrame de pandas con el método to_sql y una conexión creada con SQLAlchemy. Esta guía muestra, paso a paso y con un ejemplo sencillo, cómo hacerlo de forma fiable.

Requisitos previos

• Python 3 instalado y conocimientos básicos de pandas.
• Una base de datos SQL Server accesible y permisos para crear o escribir en una tabla.
• El ODBC Driver for SQL Server (por ejemplo, el Driver 18) instalado en la máquina.
• Las librerías pandas, SQLAlchemy y pyodbc.

Paso 1: Instalar las librerías

Empieza por instalar las tres librerías necesarias. pyodbc es el controlador que conecta Python con SQL Server, y SQLAlchemy gestiona la conexión por encima de él. Usar SQLAlchemy es el enfoque recomendado por pandas, porque simplifica la gestión de la conexión.

pip install pandas sqlalchemy pyodbc

Paso 2: Preparar el DataFrame transformado

Imagina que ya has terminado la fase de transformación y tienes los datos listos en un DataFrame. Para el ejemplo, vamos a crear un pequeño conjunto de ventas ya limpio.

import pandas as pd

df = pd.DataFrame({
    "id_venda": [1, 2, 3],
    "produto": ["Teclado", "Rato", "Monitor"],
    "valor": [29.90, 15.50, 189.00],
})
print(df)

Fíjate en que el índice de pandas (los números 0, 1, 2 a la izquierda) no forma parte de tus datos; en el paso de carga lo vamos a ignorar.

Paso 3: Crear la conexión a SQL Server

Con SQLAlchemy, la conexión se define mediante una connection string. Crea un engine, que representa la conexión a la base de datos de destino.

from sqlalchemy import create_engine

url = (
    "mssql+pyodbc://user:password@server/database"
    "?driver=ODBC+Driver+18+for+SQL+Server"
)
engine = create_engine(url, fast_executemany=True)

Sustituye user, password, server y database por tus valores. La opción fast_executemany=True acelera bastante la inserción de muchas filas en SQL Server. Buena práctica: no dejes la contraseña escrita en el código — léela de una variable de entorno (por ejemplo, con os.environ) y construye desde ahí la connection string.

Paso 4: Cargar los datos con to_sql

Ahora solo tienes que escribir el DataFrame en la tabla de destino. El método to_sql crea la tabla (si aún no existe) e inserta las filas.

df.to_sql(
    "vendas",
    con=engine,
    schema="dbo",
    if_exists="append",
    index=False,
    chunksize=1000,
)

Merece la pena entender cada parámetro:

• if_exists: "append" añade a las filas existentes; "replace" borra y vuelve a crear la tabla; "fail" da un error si la tabla ya existe.
• index=False: evita guardar el índice de pandas como una columna extra.
• chunksize=1000: envía las filas en lotes de 1000, lo que ayuda cuando el volumen es grande.

Por defecto, pandas deja que SQLAlchemy elija los tipos de las columnas. Si necesitas control, usa el parámetro dtype para indicar el tipo SQL de cada columna. Ten en cuenta, además, que en SQL Server conviene acelerar la carga con fast_executemany=True en el engine (Paso 3) en lugar de method="multi", que puede chocar con el límite de parámetros.

Paso 5: Aislar la carga en una función

En un ETL de verdad, conviene aislar la carga en una función para poder reutilizarla y probarla con facilidad.

def carregar(df, tabela, engine):
    df.to_sql(tabela, con=engine, schema="dbo",
              if_exists="append", index=False, chunksize=1000)
    print(f"Carregadas {len(df)} linhas para {tabela}.")

carregar(df, "vendas", engine)

Verificar el resultado

Para confirmar que los datos han quedado en la tabla, léelos de vuelta con pandas y cuenta las filas.

total = pd.read_sql("SELECT COUNT(*) AS n FROM dbo.vendas", engine)
print(total)

Si el número coincide con las filas que cargaste, la fase de Load ha ido bien. Como alternativa, ejecuta SELECT TOP 5 * FROM dbo.vendas en SQL Server Management Studio para ver los primeros registros.

Conclusión

Ya sabes cargar un DataFrame en SQL Server y, con ello, cerrar el ciclo Extract–Transform–Load en Python. A partir de aquí, puedes programar el script, añadir manejo de errores y cambiar if_exists="append" por una estrategia de upsert cuando necesites actualizar registros en lugar de solo insertarlos. ¿Qué parte de tu ETL vas a automatizar a continuación?