notebooks/northwind_sqlalchemy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Base de Datos Northwind con SQLAlchemy\n",
    "\n",
    "Este notebook muestra como crear una base de datos relacional usando **SQLAlchemy** en Python, cargar datos desde un archivo `.sql` externo y realizar consultas SQL directamente desde el codigo.\n",
    "\n",
    "SQLAlchemy es la libreria ORM (Object Relational Mapper) mas popular de Python. Permite interactuar con bases de datos relacionales usando Python puro o ejecutando SQL crudo. Se usa **SQLite** como motor de base de datos para que no se necesite instalar ningun servidor externo.\n",
    "\n",
    "## Estructura del proyecto\n",
    "\n",
    "El notebook asume que los dos archivos estan en el mismo directorio:\n",
    "\n",
    "- `northwind_sqlalchemy.ipynb` — este notebook\n",
    "- `northwind_data.sql` — archivo con todos los INSERT de Northwind\n",
    "\n",
    "## Contenido\n",
    "\n",
    "1. Instalacion de dependencias\n",
    "2. Creacion del motor y la sesion\n",
    "3. Definicion de tablas con el ORM\n",
    "4. Carga de datos desde el archivo SQL\n",
    "5. Consultas SQL con `text()`\n",
    "6. Consultas con el ORM\n",
    "7. Consultas avanzadas con JOINs y agregaciones"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Instalacion de Dependencias\n",
    "\n",
    "SQLAlchemy para el acceso a la base de datos y pandas para mostrar los resultados en formato de tabla."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%pip install sqlalchemy pandas --quiet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Creacion del Motor y la Sesion\n",
    "\n",
    "El `engine` es el punto de entrada principal a la base de datos. Contiene la cadena de conexion y administra el pool de conexiones. `sqlite:///northwind.db` crea la base de datos en disco con el nombre `northwind.db`. Si se usa `sqlite:///:memory:` la base existe solo en RAM y se pierde al cerrar el proceso.\n",
    "\n",
    "La `Session` actua como una unidad de trabajo: agrupa operaciones y las confirma o revierte como un bloque atomico."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sqlalchemy import (\n",
    "    create_engine, Column, Integer, String, Numeric,\n",
    "    DateTime, ForeignKey, text\n",
    ")\n",
    "from sqlalchemy.orm import declarative_base, sessionmaker, relationship\n",
    "import pandas as pd\n",
    "\n",
    "# Engine conectado a SQLite. El archivo northwind.db se crea en el directorio actual.\n",
    "# echo=False suprime el log de SQL generado por el ORM; cambia a True para depuracion.\n",
    "engine  = create_engine(\"sqlite:///northwind.db\", echo=False)\n",
    "Base    = declarative_base()\n",
    "Session = sessionmaker(bind=engine)\n",
    "session = Session()\n",
    "\n",
    "print(\"Motor creado :\", engine)\n",
    "print(\"Sesion lista :\", session)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Definicion de Tablas con el ORM\n",
    "\n",
    "Cada clase Python hereda de `Base` y representa una tabla en la base de datos. Los atributos `Column` definen las columnas con su tipo y restricciones. Las `ForeignKey` crean relaciones entre tablas y `relationship()` permite navegar entre objetos relacionados en Python sin escribir SQL adicional.\n",
    "\n",
    "Las tablas se definen en el orden que respeta las dependencias de claves foraneas: primero las tablas independientes (categories, suppliers, shippers, customers, employees) y luego las que dependen de ellas (products, orders, order_details)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Category(Base):\n",
    "    __tablename__ = \"categories\"\n",
    "    category_id   = Column(Integer, primary_key=True, autoincrement=True)\n",
    "    category_name = Column(String(25))\n",
    "    description   = Column(String(255))\n",
    "    # Relacion inversa: una categoria tiene muchos productos\n",
    "    products      = relationship(\"Product\", back_populates=\"category\")\n",
    "\n",
    "\n",
    "class Supplier(Base):\n",
    "    __tablename__ = \"suppliers\"\n",
    "    supplier_id   = Column(Integer, primary_key=True, autoincrement=True)\n",
    "    supplier_name = Column(String(50))\n",
    "    contact_name  = Column(String(50))\n",
    "    address       = Column(String(50))\n",
    "    city          = Column(String(20))\n",
    "    postal_code   = Column(String(10))\n",
    "    country       = Column(String(15))\n",
    "    phone         = Column(String(15))\n",
    "    products      = relationship(\"Product\", back_populates=\"supplier\")\n",
    "\n",
    "\n",
    "class Shipper(Base):\n",
    "    __tablename__ = \"shippers\"\n",
    "    shipper_id   = Column(Integer, primary_key=True, autoincrement=True)\n",
    "    shipper_name = Column(String(25))\n",
    "    phone        = Column(String(15))\n",
    "    orders       = relationship(\"Order\", back_populates=\"shipper\")\n",
    "\n",
    "\n",
    "class Customer(Base):\n",
    "    __tablename__ = \"customers\"\n",
    "    customer_id   = Column(Integer, primary_key=True, autoincrement=True)\n",
    "    customer_name = Column(String(50))\n",
    "    contact_name  = Column(String(50))\n",
    "    address       = Column(String(50))\n",
    "    city          = Column(String(20))\n",
    "    postal_code   = Column(String(10))\n",
    "    country       = Column(String(15))\n",
    "    orders        = relationship(\"Order\", back_populates=\"customer\")\n",
    "\n",
    "\n",
    "class Employee(Base):\n",
    "    __tablename__ = \"employees\"\n",
    "    employee_id = Column(Integer, primary_key=True, autoincrement=True)\n",
    "    last_name   = Column(String(15))\n",
    "    first_name  = Column(String(15))\n",
    "    birth_date  = Column(DateTime)\n",
    "    photo       = Column(String(25))\n",
    "    notes       = Column(String(1024))\n",
    "    orders      = relationship(\"Order\", back_populates=\"employee\")\n",
    "\n",
    "\n",
    "class Product(Base):\n",
    "    __tablename__ = \"products\"\n",
    "    product_id    = Column(Integer, primary_key=True, autoincrement=True)\n",
    "    product_name  = Column(String(50))\n",
    "    supplier_id   = Column(Integer, ForeignKey(\"suppliers.supplier_id\"))\n",
    "    category_id   = Column(Integer, ForeignKey(\"categories.category_id\"))\n",
    "    unit          = Column(String(25))\n",
    "    price         = Column(Numeric)\n",
    "    supplier      = relationship(\"Supplier\",     back_populates=\"products\")\n",
    "    category      = relationship(\"Category\",     back_populates=\"products\")\n",
    "    order_details = relationship(\"OrderDetail\",  back_populates=\"product\")\n",
    "\n",
    "\n",
    "class Order(Base):\n",
    "    __tablename__ = \"orders\"\n",
    "    order_id    = Column(Integer, primary_key=True, autoincrement=True)\n",
    "    customer_id = Column(Integer, ForeignKey(\"customers.customer_id\"))\n",
    "    employee_id = Column(Integer, ForeignKey(\"employees.employee_id\"))\n",
    "    order_date  = Column(DateTime)\n",
    "    shipper_id  = Column(Integer, ForeignKey(\"shippers.shipper_id\"))\n",
    "    customer    = relationship(\"Customer\",    back_populates=\"orders\")\n",
    "    employee    = relationship(\"Employee\",    back_populates=\"orders\")\n",
    "    shipper     = relationship(\"Shipper\",     back_populates=\"orders\")\n",
    "    details     = relationship(\"OrderDetail\", back_populates=\"order\")\n",
    "\n",
    "\n",
    "class OrderDetail(Base):\n",
    "    __tablename__ = \"order_details\"\n",
    "    order_detail_id = Column(Integer, primary_key=True, autoincrement=True)\n",
    "    order_id        = Column(Integer, ForeignKey(\"orders.order_id\"))\n",
    "    product_id      = Column(Integer, ForeignKey(\"products.product_id\"))\n",
    "    quantity        = Column(Integer)\n",
    "    order           = relationship(\"Order\",   back_populates=\"details\")\n",
    "    product         = relationship(\"Product\", back_populates=\"order_details\")\n",
    "\n",
    "\n",
    "# Crea todas las tablas en la base de datos si no existen todavia\n",
    "Base.metadata.create_all(engine)\n",
    "print(\"Tablas creadas:\", list(Base.metadata.tables.keys()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Carga de Datos desde el Archivo SQL\n",
    "\n",
    "En lugar de tener los datos fijos en el codigo, los leemos desde el archivo `northwind_data.sql`. Esto separa la logica de la aplicacion de los datos, lo cual facilita cambiar el conjunto de datos sin tocar el notebook.\n",
    "\n",
    "### Como funciona el parser\n",
    "\n",
    "El archivo `.sql` contiene sentencias `INSERT INTO NombreTabla VALUES(...)`. El parser hace lo siguiente:\n",
    "\n",
    "1. Lee el archivo linea a linea e ignora comentarios (lineas que empiezan con `--`) y lineas vacias.\n",
    "2. Identifica la tabla destino extrayendo el nombre entre `INSERT INTO` y `VALUES`.\n",
    "3. Extrae la lista de valores entre el primer `(` y el ultimo `)` de cada sentencia.\n",
    "4. Separa los valores respetando las comillas SQL: una comilla simple doble `''` dentro de un string se trata como caracter de escape, no como fin del valor.\n",
    "5. Convierte cada valor al tipo Python correcto: entero, flotante o cadena de texto.\n",
    "6. Los registros parseados se agrupan por tabla y se insertan usando los modelos ORM."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "from datetime import datetime\n",
    "\n",
    "DATA_FILE = \"northwind_data.sql\"  # cambia la ruta si el archivo esta en otro directorio\n",
    "\n",
    "\n",
    "def parse_sql_values(raw_values: str) -> list:\n",
    "    \"\"\"\n",
    "    Recibe el contenido entre los parentesis del VALUES(...) y retorna\n",
    "    una lista de valores Python, respetando strings con comillas escapadas.\n",
    "\n",
    "    El parser maneja el caso especial de SQL donde '' dentro de un string\n",
    "    es un caracter de escape para una comilla simple, no el cierre del valor.\n",
    "    \"\"\"\n",
    "    values    = []\n",
    "    current   = \"\"\n",
    "    in_string = False\n",
    "    i         = 0\n",
    "\n",
    "    while i < len(raw_values):\n",
    "        ch = raw_values[i]\n",
    "\n",
    "        if in_string:\n",
    "            if ch == \"'\":\n",
    "                # comilla doble '' es escape dentro del string SQL\n",
    "                if i + 1 < len(raw_values) and raw_values[i + 1] == \"'\":\n",
    "                    current += \"'\"\n",
    "                    i += 2\n",
    "                    continue\n",
    "                else:\n",
    "                    in_string = False\n",
    "            else:\n",
    "                current += ch\n",
    "        else:\n",
    "            if ch == \"'\":\n",
    "                in_string = True\n",
    "            elif ch == \",\":\n",
    "                values.append(current.strip())\n",
    "                current = \"\"\n",
    "                i += 1\n",
    "                continue\n",
    "            else:\n",
    "                current += ch\n",
    "        i += 1\n",
    "\n",
    "    if current.strip():\n",
    "        values.append(current.strip())\n",
    "\n",
    "    # Convertir tipos: entero, flotante o string\n",
    "    result = []\n",
    "    for v in values:\n",
    "        if v == \"NULL\":\n",
    "            result.append(None)\n",
    "        else:\n",
    "            try:\n",
    "                result.append(int(v))\n",
    "            except ValueError:\n",
    "                try:\n",
    "                    result.append(float(v))\n",
    "                except ValueError:\n",
    "                    result.append(v)\n",
    "    return result\n",
    "\n",
    "\n",
    "def load_sql_file(path: str) -> dict:\n",
    "    \"\"\"\n",
    "    Lee el archivo SQL y retorna un diccionario {tabla: [lista_de_filas]}.\n",
    "    Cada fila es una lista de valores Python listos para insertar.\n",
    "    \"\"\"\n",
    "    records = {}\n",
    "    pattern = re.compile(\n",
    "        r\"INSERT\\s+INTO\\s+(\\w+)\\s+VALUES\\s*\\((.+)\\)\\s*;\",\n",
    "        re.IGNORECASE\n",
    "    )\n",
    "\n",
    "    with open(path, encoding=\"utf-8\") as f:\n",
    "        for line in f:\n",
    "            line = line.strip()\n",
    "            if not line or line.startswith(\"--\"):\n",
    "                continue\n",
    "            match = pattern.match(line)\n",
    "            if match:\n",
    "                table  = match.group(1).lower()\n",
    "                raw    = match.group(2)\n",
    "                values = parse_sql_values(raw)\n",
    "                records.setdefault(table, []).append(values)\n",
    "\n",
    "    return records\n",
    "\n",
    "\n",
    "# Cargar el archivo y mostrar cuantas filas se leyeron por tabla\n",
    "data = load_sql_file(DATA_FILE)\n",
    "\n",
    "for table, rows in data.items():\n",
    "    print(f\"  {table:15s} -> {len(rows):4d} filas leidas\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def poblar_base_de_datos(data: dict, session) -> None:\n",
    "    \"\"\"\n",
    "    Toma el diccionario parseado del archivo SQL e inserta los registros\n",
    "    en la base de datos usando los modelos ORM.\n",
    "\n",
    "    La funcion es idempotente: solo inserta si la tabla esta vacia,\n",
    "    por lo que se puede ejecutar varias veces sin duplicar datos.\n",
    "    \"\"\"\n",
    "    if session.query(Category).count() == 0:\n",
    "        for row in data.get(\"categories\", []):\n",
    "            session.add(Category(category_name=row[0], description=row[1]))\n",
    "        session.commit()\n",
    "        print(f\"Categorias insertadas  : {session.query(Category).count()}\")\n",
    "\n",
    "    if session.query(Supplier).count() == 0:\n",
    "        for row in data.get(\"suppliers\", []):\n",
    "            session.add(Supplier(\n",
    "                supplier_name=row[0], contact_name=row[1], address=row[2],\n",
    "                city=row[3], postal_code=row[4], country=row[5], phone=row[6]\n",
    "            ))\n",
    "        session.commit()\n",
    "        print(f\"Proveedores insertados : {session.query(Supplier).count()}\")\n",
    "\n",
    "    if session.query(Shipper).count() == 0:\n",
    "        for row in data.get(\"shippers\", []):\n",
    "            session.add(Shipper(shipper_name=row[0], phone=row[1]))\n",
    "        session.commit()\n",
    "        print(f\"Transportistas        : {session.query(Shipper).count()}\")\n",
    "\n",
    "    if session.query(Customer).count() == 0:\n",
    "        for row in data.get(\"customers\", []):\n",
    "            session.add(Customer(\n",
    "                customer_name=row[0], contact_name=row[1], address=row[2],\n",
    "                city=row[3], postal_code=row[4], country=row[5]\n",
    "            ))\n",
    "        session.commit()\n",
    "        print(f\"Clientes insertados   : {session.query(Customer).count()}\")\n",
    "\n",
    "    if session.query(Employee).count() == 0:\n",
    "        for row in data.get(\"employees\", []):\n",
    "            birth = datetime.strptime(row[2], \"%Y-%m-%d\") if isinstance(row[2], str) else None\n",
    "            session.add(Employee(\n",
    "                last_name=row[0], first_name=row[1],\n",
    "                birth_date=birth, photo=row[3], notes=row[4]\n",
    "            ))\n",
    "        session.commit()\n",
    "        print(f\"Empleados insertados  : {session.query(Employee).count()}\")\n",
    "\n",
    "    if session.query(Product).count() == 0:\n",
    "        for row in data.get(\"products\", []):\n",
    "            session.add(Product(\n",
    "                product_name=row[0], supplier_id=row[1],\n",
    "                category_id=row[2], unit=row[3], price=row[4]\n",
    "            ))\n",
    "        session.commit()\n",
    "        print(f\"Productos insertados  : {session.query(Product).count()}\")\n",
    "\n",
    "    if session.query(Order).count() == 0:\n",
    "        for row in data.get(\"orders\", []):\n",
    "            order_date = datetime.strptime(row[2], \"%Y-%m-%d\") if isinstance(row[2], str) else None\n",
    "            session.add(Order(\n",
    "                customer_id=row[0], employee_id=row[1],\n",
    "                order_date=order_date, shipper_id=row[3]\n",
    "            ))\n",
    "        session.commit()\n",
    "        print(f\"Ordenes insertadas    : {session.query(Order).count()}\")\n",
    "\n",
    "    if session.query(OrderDetail).count() == 0:\n",
    "        raw_details = data.get(\"orderdetails\", [])\n",
    "        if raw_details:\n",
    "            # El archivo usa order_id absoluto (10248...) pero nuestra BD empieza en 1.\n",
    "            # Calculamos el offset para remapear los IDs correctamente.\n",
    "            min_order_id = min(row[0] for row in raw_details)\n",
    "            for row in raw_details:\n",
    "                mapped_order_id = row[0] - min_order_id + 1\n",
    "                session.add(OrderDetail(\n",
    "                    order_id=mapped_order_id,\n",
    "                    product_id=row[1],\n",
    "                    quantity=row[2]\n",
    "                ))\n",
    "        session.commit()\n",
    "        print(f\"Detalles insertados   : {session.query(OrderDetail).count()}\")\n",
    "\n",
    "\n",
    "poblar_base_de_datos(data, session)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Verificacion: conteo de registros por tabla\n",
    "tablas = [\n",
    "    (\"categories\",    Category),\n",
    "    (\"suppliers\",     Supplier),\n",
    "    (\"shippers\",      Shipper),\n",
    "    (\"customers\",     Customer),\n",
    "    (\"employees\",     Employee),\n",
    "    (\"products\",      Product),\n",
    "    (\"orders\",        Order),\n",
    "    (\"order_details\", OrderDetail),\n",
    "]\n",
    "\n",
    "resumen = pd.DataFrame(\n",
    "    [(nombre, session.query(modelo).count()) for nombre, modelo in tablas],\n",
    "    columns=[\"tabla\", \"registros\"]\n",
    ")\n",
    "resumen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Consultas SQL con `text()`\n",
    "\n",
    "SQLAlchemy permite ejecutar SQL crudo usando la funcion `text()`. Esto es util cuando se necesita control total sobre la consulta o cuando se trabaja con SQL heredado.\n",
    "\n",
    "El resultado se puede convertir directamente a un DataFrame de pandas. La funcion auxiliar `sql()` ejecuta cualquier consulta y devuelve el resultado como DataFrame. Los parametros con `:nombre` evitan inyeccion SQL al pasar valores del usuario."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sql(query, **params):\n",
    "    \"\"\"Ejecuta SQL crudo y retorna un DataFrame de pandas.\"\"\"\n",
    "    with engine.connect() as conn:\n",
    "        result = conn.execute(text(query), params)\n",
    "        return pd.DataFrame(result.fetchall(), columns=result.keys())\n",
    "\n",
    "\n",
    "# Consulta basica: todas las categorias del catalogo Northwind\n",
    "sql(\"SELECT * FROM categories\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Filtrar productos de Beverages con precio mayor a 10, usando parametros seguros\n",
    "sql(\"\"\"\n",
    "    SELECT p.product_name, p.price, c.category_name\n",
    "    FROM products p\n",
    "    JOIN categories c ON p.category_id = c.category_id\n",
    "    WHERE c.category_name = :cat\n",
    "      AND p.price > :min_price\n",
    "    ORDER BY p.price DESC\n",
    "\"\"\", cat=\"Beverages\", min_price=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Estadisticas de productos por categoria usando GROUP BY\n",
    "sql(\"\"\"\n",
    "    SELECT c.category_name,\n",
    "           COUNT(p.product_id)    AS total_products,\n",
    "           ROUND(AVG(p.price), 2) AS avg_price,\n",
    "           MIN(p.price)           AS min_price,\n",
    "           MAX(p.price)           AS max_price\n",
    "    FROM categories c\n",
    "    LEFT JOIN products p ON c.category_id = p.category_id\n",
    "    GROUP BY c.category_name\n",
    "    ORDER BY total_products DESC\n",
    "\"\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Clientes por pais — top 10\n",
    "sql(\"\"\"\n",
    "    SELECT country,\n",
    "           COUNT(*) AS total_customers\n",
    "    FROM customers\n",
    "    GROUP BY country\n",
    "    ORDER BY total_customers DESC\n",
    "    LIMIT 10\n",
    "\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. Consultas con el ORM\n",
    "\n",
    "El ORM de SQLAlchemy permite construir consultas usando objetos Python. Esto hace el codigo mas seguro y portable entre distintos motores de base de datos. Se usa `session.query()` para iniciar una consulta y metodos como `.filter()`, `.join()`, `.order_by()` y `.limit()` para construirla.\n",
    "\n",
    "Una ventaja clave del ORM es que las relaciones definidas con `relationship()` permiten navegar de un objeto a otro sin escribir SQL adicional."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ORM: los 5 productos mas caros del catalogo Northwind\n",
    "top_products = (\n",
    "    session.query(Product)\n",
    "    .order_by(Product.price.desc())\n",
    "    .limit(5)\n",
    "    .all()\n",
    ")\n",
    "\n",
    "for p in top_products:\n",
    "    print(f\"  {p.product_name:40s}  ${p.price}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ORM: clientes de Alemania con el total de ordenes de cada uno\n",
    "# relationship() permite acceder a c.orders sin escribir ninguna consulta SQL extra\n",
    "german_customers = (\n",
    "    session.query(Customer)\n",
    "    .filter(Customer.country == \"Germany\")\n",
    "    .all()\n",
    ")\n",
    "\n",
    "for c in german_customers:\n",
    "    print(f\"  {c.customer_name:35s}  Ciudad: {c.city:15s}  Ordenes: {len(c.orders)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ORM: navegar la relacion producto -> categoria -> proveedor sin escribir SQL\n",
    "# Esto demuestra el acceso en cadena a objetos relacionados\n",
    "producto = (\n",
    "    session.query(Product)\n",
    "    .filter(Product.product_name.like(\"%Cajun%\"))\n",
    "    .first()\n",
    ")\n",
    "\n",
    "if producto:\n",
    "    print(\"Producto  :\", producto.product_name)\n",
    "    print(\"Precio    :\", producto.price)\n",
    "    print(\"Categoria :\", producto.category.category_name)\n",
    "    print(\"Proveedor :\", producto.supplier.supplier_name)\n",
    "    print(\"Pais      :\", producto.supplier.country)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7. Consultas Avanzadas con JOINs y Agregaciones\n",
    "\n",
    "Combinamos varias tablas de Northwind para obtener informacion de negocio util. Este tipo de consultas es habitual en reportes y dashboards de ventas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Reporte de ventas: total de unidades vendidas y revenue por producto (top 15)\n",
    "sql(\"\"\"\n",
    "    SELECT p.product_name,\n",
    "           c.category_name,\n",
    "           SUM(od.quantity)                     AS total_units_sold,\n",
    "           ROUND(SUM(od.quantity * p.price), 2) AS total_revenue\n",
    "    FROM order_details od\n",
    "    JOIN products   p ON od.product_id = p.product_id\n",
    "    JOIN categories c ON p.category_id = c.category_id\n",
    "    GROUP BY p.product_name, c.category_name\n",
    "    ORDER BY total_revenue DESC\n",
    "    LIMIT 15\n",
    "\"\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Empleados mas activos: cuantas ordenes atendio cada uno\n",
    "sql(\"\"\"\n",
    "    SELECT e.first_name || ' ' || e.last_name AS employee_name,\n",
    "           COUNT(o.order_id)                  AS total_orders\n",
    "    FROM employees e\n",
    "    JOIN orders o ON e.employee_id = o.employee_id\n",
    "    GROUP BY e.employee_id\n",
    "    ORDER BY total_orders DESC\n",
    "\"\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Pedidos por mes usando funciones de fecha de SQLite\n",
    "sql(\"\"\"\n",
    "    SELECT strftime('%Y-%m', order_date) AS month,\n",
    "           COUNT(*)                       AS total_orders\n",
    "    FROM orders\n",
    "    GROUP BY month\n",
    "    ORDER BY month\n",
    "\"\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Subquery: clientes que hicieron mas de 2 pedidos\n",
    "sql(\"\"\"\n",
    "    SELECT c.customer_name,\n",
    "           c.country,\n",
    "           oc.total\n",
    "    FROM customers c\n",
    "    JOIN (\n",
    "        SELECT customer_id, COUNT(*) AS total\n",
    "        FROM orders\n",
    "        GROUP BY customer_id\n",
    "        HAVING COUNT(*) > 2\n",
    "    ) AS oc ON c.customer_id = oc.customer_id\n",
    "    ORDER BY oc.total DESC\n",
    "\"\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Proveedores con mas productos en el catalogo\n",
    "sql(\"\"\"\n",
    "    SELECT s.supplier_name,\n",
    "           s.country,\n",
    "           COUNT(p.product_id)    AS num_products,\n",
    "           ROUND(AVG(p.price), 2) AS avg_price\n",
    "    FROM suppliers s\n",
    "    JOIN products p ON s.supplier_id = p.supplier_id\n",
    "    GROUP BY s.supplier_id\n",
    "    ORDER BY num_products DESC\n",
    "    LIMIT 10\n",
    "\"\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Transportista mas usado en Northwind\n",
    "sql(\"\"\"\n",
    "    SELECT sh.shipper_name,\n",
    "           COUNT(o.order_id) AS shipments\n",
    "    FROM shippers sh\n",
    "    JOIN orders o ON sh.shipper_id = o.shipper_id\n",
    "    GROUP BY sh.shipper_name\n",
    "    ORDER BY shipments DESC\n",
    "\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Resumen\n",
    "\n",
    "En este notebook aprendimos a:\n",
    "\n",
    "1. Crear un motor de base de datos con `create_engine()` y conectarlo a SQLite.\n",
    "2. Definir modelos ORM como clases Python con columnas, tipos y claves foraneas.\n",
    "3. Crear las tablas en la base de datos con `Base.metadata.create_all(engine)`.\n",
    "4. Leer y parsear un archivo `.sql` externo para extraer los datos de insercion.\n",
    "5. Poblar la base de datos desde el archivo, sin datos fijos en el codigo.\n",
    "6. Ejecutar SQL crudo con `text()` y convertir los resultados a DataFrames de pandas.\n",
    "7. Usar el ORM para consultas con filtros, ordenamiento y navegacion de relaciones.\n",
    "8. Escribir consultas avanzadas con JOINs, GROUP BY, HAVING y subconsultas.\n",
    "\n",
    "Para produccion se recomienda usar PostgreSQL o MySQL en lugar de SQLite, pero la API de SQLAlchemy es identica: solo cambia la cadena de conexion del `create_engine()`."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python",
   "version": "3.9.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}