Del Navegador a la Base de Datos: El Camino Más Corto para Tablas Web

Encontraste datos en un sitio web. Los necesitas en tu base de datos.

¿Cuál es el camino más rápido del punto A al punto B?

Esta guía cubre los flujos de trabajo prácticos para llevar tablas HTML a SQLite, PostgreSQL, MySQL y otras bases de datos — con mínima fricción.

El Flujo General

Todo pipeline navegador-a-base-de-datos tiene los mismos pasos:

1. Extraer — Sacar la tabla de la página web
2. Limpiar — Corregir formato, tipos y estructura
3. Cargar — Insertar en la base de datos

La pregunta es dónde hacer cada paso y con qué herramientas.

Camino 1: CSV como Intermediario

El enfoque más común. Funciona con cualquier base de datos.

Paso 1: Exportar a CSV

Usa una extensión de navegador como HTML Table Exporter o copia y pega en una hoja de cálculo y guarda como CSV.

Consideración clave: La elección del delimitador. Las comas funcionan a menos que tus datos contengan comas. Los punto y coma o tabulaciones son más seguros para datos complejos.

Paso 2: Cargar en la Base de Datos

SQLite:

sqlite3 mydb.db
.mode csv
.import data.csv tablename

O con encabezados:

sqlite3 mydb.db <<EOF
.mode csv
.headers on
.import data.csv tablename
EOF

PostgreSQL:

COPY tablename FROM '/path/to/data.csv' 
WITH (FORMAT csv, HEADER true);

O usando psql:

\copy tablename FROM 'data.csv' WITH (FORMAT csv, HEADER true);

MySQL:

LOAD DATA INFILE '/path/to/data.csv'
INTO TABLE tablename
FIELDS TERMINATED BY ','
ENCLOSED BY '"'
LINES TERMINATED BY '\n'
IGNORE 1 ROWS;

Pros y Contras

✅ Compatibilidad universal

✅ Fácil inspeccionar el archivo intermedio

✅ Puedes corregir problemas manualmente antes de cargar

❌ Un paso extra

❌ La inferencia de tipos es básica

Camino 2: Directo a Sentencias SQL

Exportá la tabla directamente como sentencias INSERT.

Exportar como SQL

Algunas herramientas de exportación generan SQL directamente. El resultado se ve así:

INSERT INTO table_name (col1, col2, col3) VALUES
('value1', 'value2', 123),
('value4', 'value5', 456);

Cargar

Simplemente ejecutá el archivo SQL:

# SQLite
sqlite3 mydb.db < data.sql

# PostgreSQL
psql -d mydb -f data.sql

# MySQL
mysql mydb < data.sql

Pros y Contras

✅ Un solo paso de exportación a base de datos

✅ SQL es portable entre bases de datos (mayormente)

❌ Datasets grandes = archivos SQL enormes

❌ Necesitas definir el esquema de la tabla primero

Camino 3: Pipeline Python + Pandas

Máxima flexibilidad. Ideal para importaciones repetidas o limpieza compleja.

Flujo Completo

import pandas as pd
from sqlalchemy import create_engine

# Paso 1: Cargar CSV (exportado desde el navegador)
df = pd.read_csv('data.csv')

# Paso 2: Limpiar
df.columns = df.columns.str.lower().str.replace(' ', '_')  # Normalizar nombres de columnas
df['date'] = pd.to_datetime(df['date'])  # Parsear fechas
df['amount'] = df['amount'].str.replace('[$,]', '', regex=True).astype(float)  # Limpiar moneda

# Paso 3: Cargar a la base de datos
engine = create_engine('sqlite:///mydb.db')
# O: create_engine('postgresql://user:pass@localhost/mydb')
# O: create_engine('mysql+pymysql://user:pass@localhost/mydb')

df.to_sql('tablename', engine, if_exists='replace', index=False)

Mapeo de Tipos

Pandas infiere tipos, pero puedes ser explícito:

df.to_sql('tablename', engine, 
          if_exists='replace', 
          index=False,
          dtype={
              'id': Integer(),
              'name': String(100),
              'created_at': DateTime(),
              'amount': Float()
          })

Pros y Contras

✅ Control total sobre limpieza y tipos

✅ Maneja transformaciones complejas

✅ Repetible y automatizable con scripts

❌ Requiere entorno Python

❌ Excesivo para importaciones únicas

Camino 4: DuckDB (El Atajo Moderno)

DuckDB lee CSV directamente y maneja la mayor parte de la limpieza automáticamente.

Consulta Directa

-- Consultar CSV sin importar
SELECT * FROM 'data.csv';

-- Con inferencia de tipos
SELECT * FROM read_csv_auto('data.csv');

-- Crear tabla desde CSV
CREATE TABLE mytable AS SELECT * FROM 'data.csv';

Del Navegador a la Consulta en Segundos

# Exportar tabla como CSV desde el navegador
# Luego consultar directamente:
duckdb -c "SELECT column1, SUM(column2) FROM 'data.csv' GROUP BY column1;"

Sin definición de esquema. Sin paso de importación. Solo consulta.

Pros y Contras

✅ Lo más rápido para análisis ad-hoc

✅ Excelente inferencia de tipos

✅ Interfaz SQL

❌ No es una base de datos tradicional (para persistencia, exportá los resultados)

Manejando Problemas Comunes

Nombres de Columnas con Espacios

Las tablas web suelen tener encabezados como "Total Ventas" o "Acumulado Anual".

Corregir en la exportación: Algunas herramientas normalizan encabezados automáticamente.

Corregir en la importación:

df.columns = df.columns.str.replace(' ', '_').str.lower()

O en SQL después de importar:

ALTER TABLE mytable RENAME COLUMN "Total Ventas" TO total_ventas;

Formatos Numéricos Mixtos

Formato europeo (1.234,56) vs formato estadounidense (1,234.56) rompen las importaciones.

Corregir antes de importar: Usa una herramienta con presets de limpieza, o:

# Europeo a estándar
df['value'] = df['value'].str.replace('.', '').str.replace(',', '.').astype(float)

Representaciones de Nulos

Las tablas web muestran espacios en blanco, "N/A", "—", "-" para datos faltantes.

df = df.replace(['N/A', '—', '-', ''], pd.NA)

O en DuckDB:

SELECT NULLIF(column, 'N/A') AS column FROM 'data.csv';

Fechas en Varios Formatos

df['date'] = pd.to_datetime(df['date'], format='mixed', dayfirst=True)

El format='mixed' maneja formatos de fecha inconsistentes en la misma columna.

Elegir el Camino Correcto

Escenario	Camino Recomendado
Importación única, tabla chica	CSV + importación directa a la base
Importación única, necesita limpieza	Python + Pandas
Análisis rápido, sin persistencia	DuckDB
Importaciones regulares de la misma fuente	Script Python (automatizar)
Necesitas formato SQL para compartir/versionar	Exportación directa a SQL

Ejemplo: Flujo Completo

Supongamos que tenés una tabla de datos de productos en un sitio web.

Paso 1: Exportar con HTML Table Exporter → CSV con números limpios

Paso 2: Validación rápida en DuckDB:

SELECT COUNT(*), COUNT(DISTINCT product_id) FROM 'products.csv';
-- Verificar duplicados

Paso 3: Cargar a PostgreSQL:

import pandas as pd
from sqlalchemy import create_engine

df = pd.read_csv('products.csv')
engine = create_engine('postgresql://user:pass@localhost/inventory')
df.to_sql('products', engine, if_exists='replace', index=False)

Tiempo total: 2 minutos.

La Meta-Lección

El camino más corto no siempre es el más directo.

Invertir 30 segundos en limpieza durante la exportación ahorra 10 minutos depurando errores de importación. Usar el formato intermedio correcto (CSV vs SQL vs JSON) depende de tu base de datos destino y la complejidad de los datos.

Para la mayoría de los flujos tabla web → base de datos:

1. Exportar a CSV con limpieza de números/fechas
2. Cargar con la importación CSV nativa de tu base de datos
3. Solo traer Python si necesitas transformaciones complejas

Los pipelines simples son pipelines mantenibles.

Para flujos de trabajo con Python específicamente, consulta nuestra guía detallada sobre exportar tablas web a JSON para Python & Pandas.

---

¿Necesitas exportaciones limpias listas para tu base de datos? Conoce más en gauchogrid.com/es/html-table-exporter o prueba HTML Table Exporter gratis en la Chrome Web Store.