{ "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 }