Carga de CSV a SQL con SQLAlchemy y pandas

Con un enfoque práctico y directo, aquí verás cómo cargar datos limpios a una base SQL local usando SQL Alchemy y SQL Light, modelando con un ORM y automatizando la inserción desde CSV con pandas y argparse. Este flujo consolida los pasos de extraer, transformar y cargar (ETL), clave en el trabajo de un ingeniero de datos.

¿Cómo configurar SQL Alchemy y SQL Light?

Antes de escribir modelos o cargar filas, necesitas preparar el motor, la base declarativa y la sesión. SQL Alchemy actúa como capa de abstracción para múltiples motores SQL: Postgre, My Sequel, Oracle y Microsoft SQL. Si te falta la librería: conda install SQL Alchemy.

¿Qué imports y objetos clave requiere el inicio con keywords?

• Importar create engine, declarative base y session maker.
• Definir el engine para SQL Light.
• Preparar la session con session maker.
• Crear la Base para herencia de modelos.

from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.declarative import declarative_base

engine = create_engine('sqlite:///articles.db')
Session = sessionmaker(bind=engine)
Base = declarative_base()

¿Por qué SQL Alchemy es útil como ORM?

• Usa objetos de Python en lugar de queries SQL directas.
• Mantiene el código claro y portable entre backends SQL.
• Facilita el manejo de schema con Base.metadata.create_all(engine).

¿Cómo modelar con ORM el artículo?

El modelo representa la estructura de la tabla Articles. Aquí defines tipos, restricciones y el constructor que mapea los datos del CSV a columnas. La URL debe ser única, los tokens son enteros, y los textos son strings.

¿Cómo definir la clase Article con columnas y constraint único?

• Nombre de la tabla: Articles.
• Campos de texto: body, host, title, url.
• Campos numéricos: n_tokens_body, n_tokens_title.
• Restricción: url única.

from sqlalchemy import Column, String, Integer
from base import Base

class Article(Base):
    __tablename__ = 'Articles'

    uid = Column(String)
    body = Column(String)
    host = Column(String)
    newspaper_uid = Column(String)
    n_tokens_body = Column(Integer)
    n_tokens_title = Column(Integer)
    title = Column(String)
    url = Column(String, unique=True)

    def __init__(self, uid, body, host, newspaper_uid,
                 n_tokens_body, n_tokens_title, title, url):
        self.uid = uid
        self.body = body
        self.host = host
        self.newspaper_uid = newspaper_uid
        self.n_tokens_body = n_tokens_body
        self.n_tokens_title = n_tokens_title
        self.title = title
        self.url = url

¿Qué rol cumple el patrón de herencia en modelos?

• Los modelos heredan de Base para obtener funcionalidades del ORM.
• Es común en frameworks de Python como Flask o Django.
• Facilita extender y estructurar datos sin escribir SQL manual.

¿Cómo cargar CSV con pandas y argparse?

El script final combina pandas para leer CSV, argparse para recibir el archivo y SQL Alchemy para insertar filas. Se usa logging en nivel info para informar el progreso. El flujo es simple: crear schema, abrir session, iterar, agregar, commit y cerrar.

¿Cuál es el flujo ETL en el script con keywords?

• Parser con argumento file name y help: The file you want to load into the db.
• Crear el schema con Base.metadata.create_all(engine).
• Leer CSV con pandas.read csv.
• Iterar el dataframe con iter rows.
• Construir Article con argumentos posicionales.
• session add, commit y cierre de session.

import argparse
import logging
import pandas as pd

from base import Base, engine, Session
from article import Article


def main(file_name):
    Base.metadata.create_all(engine)

    session = Session()
    articles = pd.read_csv(file_name)

    for _, row in articles.iterrows():
        logging.info(f"Cargando artículo {row['uid']} en la base de datos.")
        article = Article(
            row['uid'],
            row['body'],
            row['host'],
            row['newspaper_uid'],
            row['n_tokens_body'],
            row['n_tokens_title'],
            row['title'],
            row['url']
        )
        session.add(article)

    session.commit()
    session.close()


if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument('file_name', help='The file you want to load into the db', type=str)
    args = parser.parse_args()

    logging.basicConfig(level=logging.INFO)
    main(args.file_name)

¿Cómo ejecutar el comando y validar el proceso?

• Ejecuta con Python e indica el archivo limpio.
• Observa mensajes de logging en consola.
• Verifica que los artículos se insertaron y que la URL mantiene unicidad.

Ejemplo: python main.py clean_el_universal

¿Con qué otras fuentes limpias te gustaría practicar la carga con SQL Alchemy y pandas?