DEV Community: circobit

금융 테이블 추출하기: 주식, ETF, 시장 데이터

circobit — Tue, 30 Jun 2026 00:30:00 +0000

금융 웹사이트는 테이블 데이터의 보물창고입니다. 주가, ETF 보유 내역, 시장 지수, 실적 보고서—모두 HTML 테이블에 담겨 분석을 기다리고 있습니다.

하지만 그 데이터를 사용 가능한 형태로 가져오는 것이 항상 간단하지는 않습니다.

이 가이드에서는 금융 테이블의 일반적인 문제점과 깔끔하게 추출하는 실용적 해결책을 다룹니다.

금융 테이블이 까다로운 이유

금융 데이터에는 단순한 추출을 망가뜨리는 독특한 특성이 있습니다.

혼합된 숫자 형식

미국 사이트는 1,234.56을 표시합니다. 유럽 사이트는 1.234,56을 표시합니다. 일부 금융 포털은 데이터 소스에 따라 두 형식을 혼용합니다.

Excel에 복사-붙여넣기하면 이것들이 뒤엉킵니다. 천 단위가 소수점이 됩니다. 날짜가 숫자가 됩니다. 혼돈입니다.

실시간 업데이트

많은 금융 테이블이 동적으로 업데이트됩니다. 페이지 로드 후 DOM이 변경됩니다. 너무 일찍 스크래핑하면 오래된 데이터나 빈 셀을 얻습니다.

중첩 구조

보유 내역 테이블에는 확장 가능한 행이 자주 있습니다. 펀드의 상위 보유 내역이 10개 행을 보여주고, "50개 모두 보기" 버튼 뒤에 나머지가 숨어있습니다. 숨겨진 데이터는 페이지에 존재하지만 보이지 않습니다.

퍼센트 및 통화 기호

+2.34%와 $1,234는 사람 눈에는 괜찮습니다. 스프레드시트에서는 정렬이나 계산이 제대로 작동하지 않는 텍스트 문자열입니다.

일반적인 금융 데이터 소스

Yahoo Finance

주가, 과거 데이터, 포트폴리오 보유 내역. 테이블이 비교적 깔끔하지만 동적으로 업데이트됩니다.

팁: 추출 전에 페이지가 완전히 로드될 때까지 기다리세요. 초기 렌더링에서 로딩 플레이스홀더가 표시될 수 있습니다.

Google Finance

테이블이 최소화되어 있고, 주로 카드와 차트입니다. 대량 추출에는 덜 유용합니다.

자세한 안내는 Google Finance 테이블을 Excel로 내보내기 가이드를 참고하세요.

Morningstar

펀드 보유 내역, 성과 데이터, 섹터 분류. 테이블이 잘 구성되어 있지만 종종 페이지네이션이 적용됩니다.

팁: "모두 보기" 또는 페이지네이션 컨트롤을 찾으세요. 첫 페이지에 상위 10개 보유 내역만 표시될 수 있습니다.

SEC EDGAR

제출 서류에 테이블이 포함되어 있지만 복잡한 문서에 매립되어 있습니다. 10-K와 10-Q 보고서에 재무제표가 HTML 테이블로 있습니다.

팁: 테이블은 거기 있지만 법적 텍스트로 둘러싸여 있습니다. 추출 전에 필요한 특정 테이블을 식별하세요.

MarketWatch, Investing.com, Reuters

뉴스 중심이지만 시세, 실적, 경제 캘린더에 대한 데이터 테이블을 포함합니다.

추출 전략

전략 1: 직접 내보내기

가장 단순한 접근법—데이터가 한 번만 필요할 때.

HTML Table Exporter 같은 도구가 페이지의 테이블을 감지하고 CSV 또는 Excel로 직접 내보냅니다. 코드 불필요.

금융 데이터에 특화된 사항:

숫자 형식을 정규화하는 정제 프리셋 사용
추가 처리가 필요하면 CSV, 최종 목적지라면 Excel로 내보내기
내보내기 전 동적 콘텐츠가 로드되었는지 확인

전략 2: Python + Pandas

반복 추출이나 파이프라인 통합용.

import pandas as pd

# 기본 추출
tables = pd.read_html('https://example.com/stock-data')
df = tables[0]  # 페이지의 첫 번째 테이블

# 헤더 지정
df = pd.read_html(url, header=0)[0]

# 인코딩 처리
df = pd.read_html(url, encoding='utf-8')[0]

한계: read_html은 JavaScript를 실행하지 않습니다. 동적 테이블은 로드되지 않습니다.

전략 3: 동적 콘텐츠를 위한 Selenium

JavaScript로 로드되는 테이블:

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
import pandas as pd

driver = webdriver.Chrome()
driver.get('https://example.com/stock-data')

# 테이블 로드 대기
WebDriverWait(driver, 10).until(
    EC.presence_of_element_located((By.TAG_NAME, "table"))
)

# 추출
html = driver.page_source
tables = pd.read_html(html)

트레이드오프: 설정이 더 필요하지만 JavaScript 렌더링 콘텐츠를 처리합니다.

금융 데이터 정제

원시 내보내기는 보통 정리가 필요합니다.

통화 기호 제거

df['Price'] = df['Price'].replace('[\$,]', '', regex=True).astype(float)

퍼센트 처리

df['Change'] = df['Change'].str.rstrip('%').astype(float) / 100

숫자 형식 정규화

유럽식 (1.234,56 → 1234.56):

df['Value'] = df['Value'].str.replace('.', '', regex=False)
df['Value'] = df['Value'].str.replace(',', '.', regex=False).astype(float)

날짜 파싱

금융 사이트는 일관성 없는 날짜 형식을 사용합니다.

df['Date'] = pd.to_datetime(df['Date'], format='mixed')

실용 예시: ETF 보유 내역

펀드의 보유 내역을 분석용으로 가져오려고 합니다.

수동 방법:

펀드 페이지 방문
보유 내역 테이블 찾기
Excel에 복사-붙여넣기
서식 수정에 20분 투자

효율적 방법:

보유 내역 테이블로 이동
숫자 정규화와 함께 직접 Excel로 내보내기
완료

이 차이는 누적됩니다. 매월 여러 펀드를 추적한다면 자동화가 수 시간을 절약합니다.

주의할 엣지 케이스

탭으로 분할된 테이블

일부 사이트는 다른 데이터(보유 내역, 성과, 리스크)를 탭에 표시하며 각 탭이 다른 테이블을 로드합니다. 각 탭이 별도의 추출입니다.

각주와 주석

금융 테이블은 별표와 단검 기호를 좋아합니다. 1,234*는 "추정치"를 의미할 수 있지만 숫자 파싱을 깨뜨립니다.

해결: 변환 전에 비숫자 접미사를 제거.

반복되는 헤더 행

긴 테이블은 가독성을 위해 중간에 헤더를 반복하기도 합니다. 추출 결과에 중복 헤더 행이 데이터로 포함될 수 있습니다.

해결: 모든 값이 헤더와 일치하는 행을 필터링.

자동화 vs 수동 내보내기의 기준

수동 내보내기가 적합할 때:

일회성 분석
비정기적 스케줄
매번 다른 테이블

자동화가 적합할 때:

일일/주간 반복 수집
같은 테이블, 같은 구조
더 큰 파이프라인에 통합

비정기 리서치를 하는 대부분의 분석가에게는 좋은 도구를 사용한 수동 내보내기가 스크립트를 빌드하고 유지하는 것보다 빠릅니다.

요약

금융 테이블은 가치 있지만 지저분합니다. 핵심 과제는 숫자 형식, 동적 로딩, 일관성 없는 구조입니다.

빠른 추출에는 브라우저 기반 도구가 대부분의 경우를 처리합니다. 파이프라인에는 적절한 대기와 정제를 갖춘 Python이 나머지를 처리합니다.

목표는 완벽한 자동화가 아니라—최소한의 마찰로 깨끗한 데이터를 얻는 것입니다.

금융 테이블을 빠르게 내보내야 하나요? gauchogrid.com/ko/html-table-exporter에서 자세히 알아보거나 Chrome 웹 스토어에서 HTML Table Exporter를 무료로 사용해보세요.

Financiële Tabellen Extraheren: Aandelen, ETF's en Marktdata

circobit — Mon, 29 Jun 2026 12:30:00 +0000

Financiële websites zijn goudmijnen aan tabeldata. Aandelenkoersen, ETF-posities, marktindices, kwartaalcijfers — allemaal in HTML-tabellen, klaar om geanalyseerd te worden.

Maar die data in een bruikbaar formaat krijgen is niet altijd eenvoudig.

Deze gids behandelt de veelvoorkomende uitdagingen met financiële tabellen en praktische oplossingen om ze schoon te extraheren.

Waarom Financiële Tabellen Lastig Zijn

Financiële data heeft eigenaardigheden die naïeve extractiemethoden breken.

Gemengde Getalnotaties

Amerikaanse sites tonen 1,234.56. Europese sites tonen 1.234,56. Sommige financiële portalen mengen beide, afhankelijk van de databron.

Kopiëren en plakken in Excel verpest dit vaak. Een duizendtal wordt een decimaal. Een datum wordt een getal. Chaos.

Realtime Updates

Veel financiële tabellen worden dynamisch bijgewerkt. De DOM verandert na het laden van de pagina. Als je te vroeg scrapt, krijg je verouderde data of lege cellen.

Geneste Structuren

Tabellen met posities hebben vaak uitklapbare rijen. De top-10 posities van een fonds worden getoond, met een "Alles tonen"-knop die de rest verbergt. De verborgen data staat wel op de pagina, maar is niet zichtbaar.

Percentage- en Valutasymbolen

+2,34% en €1.234 zien er prima uit voor mensen. Voor een spreadsheet zijn het tekststrings die niet correct sorteren of berekenen.

Veelvoorkomende Financiële Databronnen

Yahoo Finance

Aandelenkoersen, historische data, portefeuilleposities. Tabellen zijn relatief schoon maar worden dynamisch bijgewerkt.

Tip: Wacht tot de pagina volledig is geladen voordat je extraheert. De eerste render toont vaak laad-placeholders.

Google Finance

Minimale tabellen, vooral kaarten en grafieken. Minder geschikt voor bulkextractie.

Bekijk voor een gedetailleerde uitleg onze gids over het exporteren van Google Finance-tabellen naar Excel.

Morningstar

Fondsposities, prestatiegegevens, sectorverdelingen. Tabellen zijn goed gestructureerd maar vaak gepagineerd.

Tip: Zoek naar "Alles tonen" of paginatieknoppen. De eerste pagina toont mogelijk alleen de top 10 posities.

SEC EDGAR

Rapportages bevatten tabellen, maar ze zijn ingebed in complexe documenten. 10-K- en 10-Q-rapporten bevatten financiële overzichten als HTML-tabellen.

Tip: De tabellen zijn er, maar omgeven door juridische tekst. Identificeer de specifieke tabel die je nodig hebt voordat je extraheert.

MarketWatch, Investing.com, Reuters

Nieuwsgericht maar met datatableellen voor koersen, kwartaalcijfers en economische kalenders.

Extractiestrategieën

Strategie 1: Directe Export

De eenvoudigste aanpak — als je de data slechts één keer nodig hebt.

Tools zoals HTML Table Exporter detecteren tabellen op de pagina en exporteren direct naar CSV of Excel. Geen code nodig.

Specifiek voor financiële data:

Gebruik schoonmaakpresets die getalnotaties normaliseren
Exporteer naar CSV als je verder verwerkt; Excel als het de einddestinatie is
Controleer of dynamische content is geladen voordat je exporteert

Strategie 2: Python + Pandas

Voor herhaalde extractie of integratie in pipelines.

import pandas as pd

# Basisextractie
tables = pd.read_html('https://example.com/stock-data')
df = tables[0]  # Eerste tabel op de pagina

# Met headerspecificatie
df = pd.read_html(url, header=0)[0]

# Encoding afhandelen
df = pd.read_html(url, encoding='utf-8')[0]

Beperkingen: read_html voert geen JavaScript uit. Dynamische tabellen worden niet geladen.

Strategie 3: Selenium voor Dynamische Content

Wanneer tabellen via JavaScript laden:

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
import pandas as pd

driver = webdriver.Chrome()
driver.get('https://example.com/stock-data')

# Wacht tot de tabel is geladen
WebDriverWait(driver, 10).until(
    EC.presence_of_element_located((By.TAG_NAME, "table"))
)

# Extraheren
html = driver.page_source
tables = pd.read_html(html)

Afweging: Meer opzet nodig, maar verwerkt JavaScript-gerenderde content.

Financiële Data Opschonen

Ruwe exports hebben meestal opschoonwerk nodig.

Valutasymbolen Verwijderen

df['Price'] = df['Price'].replace('[\$,]', '', regex=True).astype(float)

Percentages Afhandelen

df['Change'] = df['Change'].str.rstrip('%').astype(float) / 100

Getalnotaties Normaliseren

Voor Europees formaat (1.234,56 → 1234.56):

df['Value'] = df['Value'].str.replace('.', '', regex=False)
df['Value'] = df['Value'].str.replace(',', '.', regex=False).astype(float)

Datums Parsen

Financiële sites gebruiken inconsistente datumformaten.

df['Date'] = pd.to_datetime(df['Date'], format='mixed')

Praktijkvoorbeeld: ETF-posities

Stel dat je de posities van een fonds wilt analyseren.

De handmatige manier:

Bezoek de fondspagina
Zoek de positietabel
Kopieer en plak in Excel
Besteed 20 minuten aan het herstellen van opmaak

De efficiënte manier:

Navigeer naar de positietabel
Exporteer direct naar Excel met getalnormalisatie
Klaar

Het verschil stapelt op. Als je maandelijks meerdere fondsen volgt, bespaar je met automatisering uren.

Randgevallen om op te Letten

Tabellen Verdeeld over Tabs

Sommige sites tonen verschillende data (Posities, Prestaties, Risico) in tabs die verschillende tabellen laden. Elke tab is een aparte extractie.

Voetnoten en Annotaties

Financiële tabellen houden van sterretjes en kruisjes. 1.234* kan "geschat" betekenen, maar breekt numerieke parsing.

Oplossing: Strip niet-numerieke achtervoegsels vóór conversie.

Herhaalde Koprijen

Lange tabellen herhalen soms headers halverwege voor leesbaarheid. Je extractie kan dubbele koprijen als data bevatten.

Oplossing: Filter rijen waar alle waarden overeenkomen met de header.

Wanneer Automatiseren vs. Wanneer Handmatig Exporteren

Handmatige export werkt bij:

Eenmalige analyse
Onregelmatig schema
Steeds verschillende tabellen

Automatisering werkt bij:

Dagelijkse/wekelijkse terugkerende pulls
Dezelfde tabellen, dezelfde structuur
Integratie in grotere pipelines

Voor de meeste analisten die incidenteel onderzoek doen, is handmatige export met een goede tool sneller dan scripts bouwen en onderhouden.

Samenvatting

Financiële tabellen zijn waardevol maar rommelig. De belangrijkste uitdagingen zijn getalnotaties, dynamisch laden en inconsistente structuur.

Voor snelle extracties verwerken browsertools de meeste gevallen. Voor pipelines doet Python met de juiste wachttijden en opschoning de rest.

Het doel is niet perfecte automatisering — het is schone data met minimale wrijving.

Wil je financiële tabellen snel exporteren? Meer info op gauchogrid.com/nl/html-table-exporter of probeer HTML Table Exporter gratis in de Chrome Web Store.

Extraire des Tableaux Financiers : Actions, ETF et Données de Marché

circobit — Mon, 29 Jun 2026 08:00:00 +0000

Les sites financiers sont des mines d'or de données tabulaires. Cours d'actions, compositions d'ETF, indices de marché, rapports de résultats — tout dans des tableaux HTML, en attente d'être analysés.

Mais obtenir ces données dans un format exploitable n'est pas toujours simple.

Ce guide couvre les défis courants des tableaux financiers et les solutions pratiques pour les extraire proprement.

Pourquoi les Tableaux Financiers Sont Difficiles

Les données financières ont des particularités qui cassent les méthodes d'extraction naïves.

Formats Numériques Mixtes

Les sites américains affichent 1,234.56. Les sites européens affichent 1.234,56. Certains portails financiers mélangent les deux selon la source des données.

Le copier-coller dans Excel modifie souvent ces formats. Un millier devient une décimale. Une date devient un nombre. Le chaos.

Mises à Jour en Temps Réel

De nombreux tableaux financiers se mettent à jour dynamiquement. Le DOM change après le chargement de la page. Si vous scrapez trop tôt, vous obtenez des données obsolètes ou des cellules vides.

Structures Imbriquées

Les tableaux de positions contiennent souvent des lignes extensibles. Les principales positions d'un fonds peuvent montrer 10 lignes, avec un bouton « Afficher les 50 » cachant le reste. Les données masquées existent dans la page mais ne sont pas visibles.

Symboles de Pourcentage et de Devise

+2,34 % et 1 234 € ont belle allure pour les humains. Pour un tableur, ce sont des chaînes de texte qui ne se trient ni ne se calculent correctement.

Sources de Données Financières Courantes

Yahoo Finance

Cotations, données historiques, positions de portefeuille. Les tableaux sont relativement propres mais se mettent à jour dynamiquement.

Conseil : Attendez que la page soit entièrement chargée avant d'extraire. Le rendu initial affiche souvent des emplacements de chargement.

Google Finance

Peu de tableaux, surtout des cartes et des graphiques. Moins utile pour l'extraction en masse.

Morningstar

Positions de fonds, données de performance, répartitions sectorielles. Les tableaux sont bien structurés mais souvent paginés.

Conseil : Cherchez les contrôles « Tout afficher » ou de pagination. La première page pourrait ne montrer que les 10 premières positions.

SEC EDGAR

Les dépôts contiennent des tableaux, mais ils sont intégrés dans des documents complexes. Les rapports 10-K et 10-Q ont les états financiers sous forme de tableaux HTML.

MarketWatch, Investing.com, Reuters

Orientés actualités mais incluent des tableaux de données pour les cotations, les résultats et les calendriers économiques.

Stratégies d'Extraction

Stratégie 1 : Export Direct

L'approche la plus simple — si vous n'avez besoin des données qu'une seule fois.

Des outils comme HTML Table Exporter détectent les tableaux sur la page et exportent directement en CSV ou Excel. Aucun code requis.

Pour les données financières spécifiquement :

Utilisez les préréglages de nettoyage qui normalisent les formats numériques
Exportez en CSV si vous traiterez ensuite ; en Excel si c'est la destination finale
Vérifiez que le contenu dynamique est chargé avant d'exporter

Stratégie 2 : Python + Pandas

Pour l'extraction récurrente ou l'intégration dans des pipelines.

import pandas as pd

# Extraction basique
tables = pd.read_html('https://example.com/stock-data')
df = tables[0]  # Premier tableau de la page

# Avec spécification d'en-tête
df = pd.read_html(url, header=0)[0]

# Gestion de l'encodage
df = pd.read_html(url, encoding='utf-8')[0]

Limitations : read_html n'exécute pas le JavaScript. Les tableaux dynamiques ne se chargeront pas.

Stratégie 3 : Selenium pour le Contenu Dynamique

Quand les tableaux se chargent via JavaScript :

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
import pandas as pd

driver = webdriver.Chrome()
driver.get('https://example.com/stock-data')

# Attendre le chargement du tableau
WebDriverWait(driver, 10).until(
    EC.presence_of_element_located((By.TAG_NAME, "table"))
)

# Extraire
html = driver.page_source
tables = pd.read_html(html)

Compromis : Plus de configuration, mais gère le contenu rendu par JavaScript.

Nettoyer les Données Financières

Les exports bruts nécessitent généralement un nettoyage.

Supprimer les Symboles Monétaires

df['Prix'] = df['Prix'].replace('[\$€,]', '', regex=True).astype(float)

Gérer les Pourcentages

df['Variation'] = df['Variation'].str.rstrip('%').astype(float) / 100

Normaliser les Formats Numériques

Pour le format européen (1.234,56 → 1234.56) :

df['Valeur'] = df['Valeur'].str.replace('.', '', regex=False)
df['Valeur'] = df['Valeur'].str.replace(',', '.', regex=False).astype(float)

Parser les Dates

Les sites financiers utilisent des formats de date incohérents.

df['Date'] = pd.to_datetime(df['Date'], format='mixed')

Cas Limites à Surveiller

Tableaux Répartis sur des Onglets

Certains sites affichent différentes données (Positions, Performance, Risque) dans des onglets qui chargent des tableaux différents. Chaque onglet est une extraction séparée.

Notes de Bas de Page et Annotations

Les tableaux financiers adorent les astérisques et les croix. 1 234* peut signifier « estimé » mais casse le parsing numérique.

Solution : Supprimer les suffixes non-numériques avant la conversion.

Lignes d'En-tête Répétées

Les longs tableaux répètent parfois les en-têtes en milieu de tableau pour la lisibilité. Votre extraction pourrait inclure des lignes d'en-tête dupliquées comme données.

Solution : Filtrer les lignes dont toutes les valeurs correspondent à l'en-tête.

Quand Automatiser vs. Quand Exporter Manuellement

L'export manuel fonctionne quand :

Analyse ponctuelle
Calendrier irrégulier
Tableaux différents à chaque fois

L'automatisation fonctionne quand :

Extractions quotidiennes/hebdomadaires récurrentes
Mêmes tableaux, même structure
Intégration dans des pipelines plus larges

Pour la plupart des analystes faisant de la recherche occasionnelle, l'export manuel avec un bon outil est plus rapide que construire et maintenir des scripts.

Résumé

Les tableaux financiers sont précieux mais désordonnés. Les défis principaux sont les formats numériques, le chargement dynamique et la structure incohérente.

Pour les extractions rapides, les outils basés sur le navigateur gèrent la plupart des cas. Pour les pipelines, Python avec les attentes et le nettoyage appropriés gère le reste.

L'objectif n'est pas l'automatisation parfaite — c'est d'obtenir des données propres avec un minimum de friction.

Pour une comparaison des outils disponibles, consultez notre guide sur les meilleures extensions Chrome pour copier des tableaux dans Excel.

Besoin d'exporter des tableaux financiers rapidement ? En savoir plus sur gauchogrid.com/fr/html-table-exporter ou essayez HTML Table Exporter gratuitement sur le Chrome Web Store.

De Tabela HTML a INSERT SQL em Um Clique

circobit — Thu, 25 Jun 2026 12:00:00 +0000

Você encontrou dados em um site. Precisa deles no seu banco de dados. O fluxo geralmente envolve: exportar para CSV, importar na ferramenta SQL, lidar com incompatibilidades de tipo, corrigir problemas de encoding.

E se você pudesse ir direto da tabela HTML para SQL válido?

Este guia mostra como gerar instruções CREATE TABLE e INSERT INTO a partir de qualquer tabela web, lidando com inferência de tipos, sanitização de identificadores e escape adequado. Esta é a abordagem que uso no HTML Table Exporter.

O Resultado Final

De uma tabela como esta:

| Nome do Produto | Preço  | Em Estoque |
|-----------------|--------|------------|
| Widget Pro      | 29.99  | Sim        |
| Gadget Basic    | 14.50  | Não        |

Gerar:

-- Exportado pelo HTML Table Exporter PRO

CREATE TABLE produtos (
  nome_do_produto TEXT,
  preco REAL,
  em_estoque TEXT
);

INSERT INTO produtos (nome_do_produto, preco, em_estoque) VALUES
  ('Widget Pro', 29.99, 'Sim'),
  ('Gadget Basic', 14.50, 'Não');

Vamos construir isso passo a passo.

Passo 1: Extrair a Matriz da Tabela

Primeiro, extrair os dados brutos da tabela HTML:

function extractTableMatrix(table) {
  const rows = Array.from(table.rows);
  const grid = [];

  rows.forEach((rowEl, rowIndex) => {
    if (!grid[rowIndex]) grid[rowIndex] = [];
    let colIndex = 0;

    Array.from(rowEl.cells).forEach(cell => {
      while (grid[rowIndex][colIndex] !== undefined) colIndex++;

      const text = cell.textContent.trim();
      const rowSpan = parseInt(cell.rowSpan) || 1;
      const colSpan = parseInt(cell.colSpan) || 1;

      for (let r = 0; r < rowSpan; r++) {
        if (!grid[rowIndex + r]) grid[rowIndex + r] = [];
        for (let c = 0; c < colSpan; c++) {
          grid[rowIndex + r][colIndex + c] = text;
        }
      }
      colIndex += colSpan;
    });
  });

  return grid;
}

Saída: Um array 2D onde rows[0] são cabeçalhos e rows[1+] são dados.

Passo 2: Sanitizar Nomes de Colunas

Identificadores SQL têm regras estritas. Cabeçalhos como "Nome do Produto" ou "Preço (R$)" precisam de sanitização:

function sanitizeSqlIdentifier(header, fallbackIndex) {
  let id = (header || "").toString().trim();

  if (!id) {
    return `col_${fallbackIndex + 1}`;
  }

  // Normalizar unicode (remover acentos)
  id = id.normalize("NFD").replace(/[\u0300-\u036f]/g, "");

  // Converter para snake_case minúsculo
  id = id
    .toLowerCase()
    .replace(/[^a-z0-9]+/g, "_")
    .replace(/^_+|_+$/g, "");

  // Garantir que não começa com número
  if (/^\d/.test(id)) {
    id = `col_${id}`;
  }

  // Fallback se vazio após sanitização
  if (!id) {
    return `col_${fallbackIndex + 1}`;
  }

  return id;
}

// Exemplos:
// "Nome do Produto" → "nome_do_produto"
// "Preço (R$)"      → "preco_r"
// "2024 Receita"    → "col_2024_receita"
// ""                → "col_1"

Passo 3: Tratar Nomes de Colunas Duplicados

Tabelas às vezes têm cabeçalhos duplicados. SQL exige nomes de colunas únicos:

function makeUniqueColumnNames(headers) {
  const used = new Set();

  return headers.map((header, idx) => {
    let name = sanitizeSqlIdentifier(header, idx);
    let candidate = name;
    let counter = 1;

    while (used.has(candidate)) {
      candidate = `${name}_${counter}`;
      counter++;
    }

    used.add(candidate);
    return candidate;
  });
}

// ["Nome", "Nome", "Valor"] → ["nome", "nome_1", "valor"]

Passo 4: Inferir Tipos SQL

Analisar dados para determinar os tipos SQL apropriados:

function inferSqlColumnTypes(rows, headerRowIndex = 0) {
  const headerRow = rows[headerRowIndex] || [];
  const dataRows = rows.slice(headerRowIndex + 1);
  const types = new Array(headerRow.length).fill("TEXT");

  for (let col = 0; col < headerRow.length; col++) {
    // Amostrar até 50 valores por coluna
    const values = [];
    for (let r = 0; r < Math.min(dataRows.length, 50); r++) {
      const cell = dataRows[r][col];
      const v = cell != null ? String(cell).trim() : "";
      if (v !== "") values.push(v);
    }

    if (values.length === 0) {
      types[col] = "TEXT";
      continue;
    }

    // Verificar se todos os valores correspondem a um tipo
    let allInt = true;
    let allNumeric = true;

    for (const v of values) {
      if (!/^[-+]?\d+$/.test(v)) {
        allInt = false;
      }
      if (!/^[-+]?\d+([.,]\d+)?$/.test(v)) {
        allNumeric = false;
      }
    }

    if (allInt) {
      types[col] = "INTEGER";
    } else if (allNumeric) {
      types[col] = "REAL";
    } else {
      types[col] = "TEXT";
    }
  }

  return types;
}

Prioridade de tipos: INTEGER > REAL > TEXT

Se 100% dos valores não-vazios são inteiros, usa INTEGER. Se são todos numéricos (incluindo decimais), usa REAL. Caso contrário, TEXT.

Passo 5: Escapar Valores Corretamente

Injeção SQL não é apenas uma preocupação de segurança — corrompe seus dados. Escape adequado:

function sqlEscapeValue(raw, type) {
  // Tratamento de NULL
  if (raw == null) return "NULL";

  const v = String(raw).trim();
  if (v === "") return "NULL";

  // Tipos numéricos
  if (type === "INTEGER" || type === "REAL") {
    // Normalizar separador decimal
    const normalized = v.replace(",", ".");
    const num = Number(normalized);

    if (!Number.isNaN(num) && Number.isFinite(num)) {
      return normalized;
    }
    // Cair para TEXT se não for um número válido
  }

  // TEXT: escapar aspas simples duplicando-as
  const escaped = v.replace(/'/g, "''");
  return `'${escaped}'`;
}

// Exemplos:
// sqlEscapeValue("Olá", "TEXT")         → "'Olá'"
// sqlEscapeValue("It's good", "TEXT")   → "'It''s good'"
// sqlEscapeValue("29.99", "REAL")       → "29.99"
// sqlEscapeValue("", "TEXT")            → "NULL"
// sqlEscapeValue(null, "TEXT")          → "NULL"

Passo 6: Gerar o SQL

Juntando tudo:

function tableToSql(tableInfo) {
  const rows = tableInfo.rows || [];
  if (rows.length < 2) return "";

  const headerRowIndex = tableInfo.headerRowIndex || 0;
  const headerRow = rows[headerRowIndex];
  const dataRows = rows.slice(headerRowIndex + 1);

  if (!headerRow || headerRow.length === 0) return "";

  // Gerar nomes de colunas
  const columnNames = makeUniqueColumnNames(headerRow);

  // Inferir tipos
  const types = inferSqlColumnTypes(rows, headerRowIndex);

  // Gerar nome da tabela
  const rawTableName = tableInfo.name || tableInfo.slug || "tabela";
  const tableName = sanitizeSqlIdentifier(rawTableName, 0) || "tabela_exportada";

  // Instrução CREATE TABLE
  const createLines = columnNames.map((col, i) => 
    `  ${col} ${types[i] || "TEXT"}`
  );
  const createStmt = `CREATE TABLE ${tableName} (\n${createLines.join(",\n")}\n);`;

  // Instruções INSERT
  const insertHeader = `INSERT INTO ${tableName} (${columnNames.join(", ")}) VALUES`;

  const valueLines = dataRows.map(row => {
    const values = columnNames.map((_, i) => {
      const cell = row[i];
      const type = types[i] || "TEXT";
      return sqlEscapeValue(cell, type);
    });
    return `  (${values.join(", ")})`;
  });

  // Combinar
  let sql = `-- Exportado pelo HTML Table Exporter\n\n${createStmt}\n\n`;

  if (valueLines.length > 0) {
    sql += `${insertHeader}\n${valueLines.join(",\n")};\n`;
  }

  return sql;
}

Exemplo Completo

Tabela de entrada:

const tableInfo = {
  name: "Vendas Q1",
  rows: [
    ["Produto", "Unid. Vendidas", "Receita (R$)", "Lucrativo"],
    ["Widget A", "1.234", "45.678,90", "Sim"],
    ["Widget B", "567", "12.345,67", "Não"],
    ["Gadget X", "890", "23.456,78", "Sim"]
  ]
};

Saída:

-- Exportado pelo HTML Table Exporter

CREATE TABLE vendas_q1 (
  produto TEXT,
  unid_vendidas INTEGER,
  receita_r REAL,
  lucrativo TEXT
);

INSERT INTO vendas_q1 (produto, unid_vendidas, receita_r, lucrativo) VALUES
  ('Widget A', 1234, 45678.90, 'Sim'),
  ('Widget B', 567, 12345.67, 'Não'),
  ('Gadget X', 890, 23456.78, 'Sim');

Observe:

Nomes de colunas sanitizados (Receita (R$) → receita_r)
Números detectados e sem aspas
Vírgulas nos números tratadas
Nome da tabela vindo dos metadados

Tratando Casos Extremos

Valores NULL

Muitas tabelas web representam dados ausentes de formas diferentes:

const NULL_PATTERNS = ["N/A", "n/a", "N/D", "-", "--", "null", "none", "nenhum", "."];

function sqlEscapeValue(raw, type, nullPatterns = NULL_PATTERNS) {
  if (raw == null) return "NULL";

  const v = String(raw).trim();
  if (v === "" || nullPatterns.includes(v.toLowerCase())) {
    return "NULL";
  }

  // ... resto da função
}

Grandes Conjuntos de Dados

Para tabelas com milhares de linhas, divida os INSERTs em lotes:

function tableToSqlBatched(tableInfo, batchSize = 1000) {
  // ... mesma configuração ...

  const batches = [];
  for (let i = 0; i < valueLines.length; i += batchSize) {
    const batch = valueLines.slice(i, i + batchSize);
    batches.push(`${insertHeader}\n${batch.join(",\n")};`);
  }

  return `${createStmt}\n\n${batches.join("\n\n")}`;
}

Sintaxe Específica por Banco de Dados

SQLite, PostgreSQL e MySQL têm diferenças sutis de sintaxe:

function tableToSql(tableInfo, dialect = "sqlite") {
  // ... mesma lógica de colunas/tipos ...

  // Mapeamento de tipos específico por dialeto
  const typeMap = {
    sqlite: { INTEGER: "INTEGER", REAL: "REAL", TEXT: "TEXT" },
    postgresql: { INTEGER: "INTEGER", REAL: "NUMERIC", TEXT: "TEXT" },
    mysql: { INTEGER: "INT", REAL: "DECIMAL(10,2)", TEXT: "VARCHAR(255)" }
  };

  const dialectTypes = typeMap[dialect] || typeMap.sqlite;

  const createLines = columnNames.map((col, i) => 
    `  ${col} ${dialectTypes[types[i]] || dialectTypes.TEXT}`
  );

  // ... resto da função ...
}

Bookmarklet para o Navegador

Solução rápida para uso ocasional:

javascript:(function(){
  const table = document.querySelector("table");
  if (!table) { alert("Nenhuma tabela encontrada"); return; }

  const rows = Array.from(table.rows).map(r => 
    Array.from(r.cells).map(c => c.textContent.trim())
  );

  const headers = rows[0].map((h, i) => 
    (h || `col_${i+1}`).toLowerCase().replace(/[^a-z0-9]+/g, "_")
  );

  const values = rows.slice(1).map(row => 
    "(" + row.map(v => `'${v.replace(/'/g, "''")}'`).join(", ") + ")"
  ).join(",\n");

  const sql = `INSERT INTO table_data (${headers.join(", ")}) VALUES\n${values};`;

  navigator.clipboard.writeText(sql);
  alert("SQL copiado para a área de transferência!");
})();

Quando Usar Isso

Bom para:

Importações rápidas de dados para SQLite/PostgreSQL
Popular bancos de dados de teste
Migrações de dados pontuais
Aprender SQL por exemplos

Não ideal para:

ETL em larga escala (use ferramentas próprias)
Schemas complexos (chaves estrangeiras, constraints)
Dados binários

Para pipelines de dados em produção, ferramentas ETL com validação são melhores. Para "preciso desta tabela no meu banco agora", geração direta de SQL é rápida.

Experimente Sem Código

Se não quer construir isso você mesmo, o HTML Table Exporter PRO gera SQL com um clique. A versão gratuita exporta para CSV/JSON/Excel; a PRO adiciona SQL, NDJSON e limpeza de dados.

Para saber qual é a melhor extensão Chrome para copiar tabelas para planilhas, confira nossa análise comparativa.

Saiba mais em gauchogrid.com/pt-br/html-table-exporter ou experimente na Chrome Web Store.

Para qual banco de dados você está importando dados web? Tenho curiosidade sobre os casos de uso.

Converting Web Tables to SQL INSERT Statements

circobit — Wed, 24 Jun 2026 14:00:00 +0000

You have a table on a webpage. You need it in your database.

The manual approach: copy to Excel, clean up, export CSV, write CREATE TABLE by hand, use LOAD DATA or COPY, debug the errors.

The better approach: generate complete SQL directly—CREATE TABLE with inferred types, INSERT statements with proper escaping.

Here's how to build a web table to SQL converter.

The Output Format

A complete SQL export should include:

-- Exported from HTML Table Exporter PRO

CREATE TABLE products (
  product_id INTEGER,
  name TEXT,
  price REAL,
  in_stock TEXT
);

INSERT INTO products (product_id, name, price, in_stock) VALUES
  (1, 'Widget', 29.99, 'true'),
  (2, 'Gadget', 49.99, 'false'),
  (3, 'O''Brien''s Special', 19.99, 'true');

Key requirements:

Valid table name (SQL-safe identifier)
Valid column names (no spaces, no special characters)
Appropriate column types (INTEGER, REAL, TEXT)
Properly escaped values (single quotes doubled)
NULL handling

Step 1: Sanitizing Identifiers

SQL identifiers (table and column names) have strict rules:

No spaces or special characters
Can't start with a digit
Should be lowercase for portability

function sanitizeSqlIdentifier(name, fallback) {
  let id = (name || "").toString().trim();

  if (!id) id = fallback || "col";

  id = id
    .normalize("NFD")
    .replace(/[\u0300-\u036f]/g, "")  // Remove accents (café → cafe)
    .toLowerCase()
    .replace(/[^a-z0-9_]+/g, "_")     // Replace invalid chars with underscore
    .replace(/^_+|_+$/g, "");          // Trim leading/trailing underscores

  // SQL identifiers can't start with a digit
  if (/^[0-9]/.test(id)) {
    id = "_" + id;
  }

  if (!id) id = fallback || "col";
  return id;
}

Examples:

"Product Name" → "product_name"
"Price ($)" → "price"
"2024 Revenue" → "_2024_revenue"
"Préço" → "preco"

Step 2: Generating Unique Column Names

Tables can have duplicate headers. SQL can't have duplicate column names.

function generateColumnNames(headerRow) {
  const usedNames = new Set();

  return headerRow.map((header, index) => {
    const base = sanitizeSqlIdentifier(header, `col_${index + 1}`);
    let candidate = base;
    let counter = 1;

    while (usedNames.has(candidate)) {
      candidate = `${base}_${counter}`;
      counter++;
    }

    usedNames.add(candidate);
    return candidate;
  });
}

Examples:

["Name", "Name", "Value"] → ["name", "name_1", "value"]
["", "", "Data"] → ["col_1", "col_2", "data"]

Step 3: Inferring Column Types

SQL has three main types we care about:

INTEGER: Whole numbers
REAL: Decimal numbers
TEXT: Everything else

The inference samples values from the column and picks the most specific type that fits all values:

function inferSqlColumnTypes(rows, headerRowIndex = 0) {
  const headerRow = rows[headerRowIndex] || [];
  const dataRows = rows.slice(headerRowIndex + 1);

  const colCount = headerRow.length;
  const types = new Array(colCount).fill("TEXT");

  for (let col = 0; col < colCount; col++) {
    // Sample up to 50 non-empty values
    const values = [];

    for (let r = 0; r < dataRows.length && values.length < 50; r++) {
      const cell = dataRows[r][col];
      const v = cell != null ? String(cell).trim() : "";
      if (v !== "") values.push(v);
    }

    if (values.length === 0) {
      types[col] = "TEXT";
      continue;
    }

    // Check if all values are integers
    let allInt = true;
    let allNumeric = true;

    for (const v of values) {
      if (!/^[-+]?\d+$/.test(v)) {
        allInt = false;
      }
      if (!/^[-+]?\d+([.,]\d+)?$/.test(v)) {
        allNumeric = false;
      }
    }

    if (allInt) {
      types[col] = "INTEGER";
    } else if (allNumeric) {
      types[col] = "REAL";
    } else {
      types[col] = "TEXT";
    }
  }

  return types;
}

Key decisions:

Sample only 50 values for performance on large tables
INTEGER is stricter than REAL (no decimals allowed)
If ANY value doesn't match, fall back to TEXT
Empty columns default to TEXT

Step 4: Escaping Values

SQL strings require escaping single quotes by doubling them:

function sqlEscapeValue(raw, type) {
  // NULL handling
  if (raw == null) return "NULL";

  const v = String(raw).trim();
  if (v === "") return "NULL";

  // For numeric types, try to return unquoted number
  if (type === "INTEGER" || type === "REAL") {
    const normalized = v.replace(",", ".");  // Handle EU decimal format
    const num = Number(normalized);

    if (!Number.isNaN(num) && Number.isFinite(num)) {
      return normalized;
    }
    // Fall through to TEXT handling if not a valid number
  }

  // TEXT or fallback: escape single quotes
  const escaped = v.replace(/'/g, "''");
  return `'${escaped}'`;
}

Examples:

"Hello" → 'Hello'
"O'Brien" → 'O''Brien'
"It's \"quoted\"" → 'It''s "quoted"'
123 (INTEGER) → 123
45.67 (REAL) → 45.67
"" → NULL
null → NULL

Step 5: Generating the Complete SQL

function tableToSqlString(tableInfo) {
  const rows = tableInfo.rows || [];
  if (!rows.length) return "";

  const headerRowIndex = tableInfo.headerRowIndex || 0;
  const headerRow = rows[headerRowIndex];
  const dataRows = rows.slice(headerRowIndex + 1);

  if (!headerRow) return "";

  // Generate safe column names
  const columnNames = generateColumnNames(headerRow);

  // Infer column types
  const types = inferSqlColumnTypes(rows, headerRowIndex);

  // Generate safe table name
  const rawTableName = tableInfo.slug || tableInfo.name || "table";
  let tableName = sanitizeSqlIdentifier(rawTableName, "table");
  if (!tableName) tableName = "table_export";

  // BUILD CREATE TABLE
  const createLines = columnNames.map((col, i) => 
    `  ${col} ${types[i] || "TEXT"}`
  );
  const createStmt = `CREATE TABLE ${tableName} (\n${createLines.join(",\n")}\n);`;

  // BUILD INSERT STATEMENTS
  const insertHeader = `INSERT INTO ${tableName} (${columnNames.join(", ")}) VALUES`;

  const valueLines = dataRows.map(row => {
    const values = columnNames.map((_, i) => {
      const cell = row[i];
      const type = types[i] || "TEXT";
      return sqlEscapeValue(cell, type);
    });
    return `  (${values.join(", ")})`;
  });

  // COMBINE
  let sql = `-- Exported from HTML Table Exporter PRO\n\n${createStmt}\n\n`;

  if (valueLines.length) {
    sql += `${insertHeader}\n${valueLines.join(",\n")};\n`;
  }

  return sql;
}

Example Output

Input table:

Product	Price	Qty
Widget	29.99	100
O'Brien's	19.99	50

Output:

-- Exported from HTML Table Exporter PRO

CREATE TABLE products (
  product TEXT,
  price REAL,
  qty INTEGER
);

INSERT INTO products (product, price, qty) VALUES
  ('Widget', 29.99, 100),
  ('O''Brien''s', 19.99, 50);

Handling Edge Cases

Empty Tables

if (!rows.length) return "";
if (!headerRow) return "";

Return empty string rather than invalid SQL.

All-NULL Columns

Columns with only empty/null values get TEXT type. The inference function handles this:

if (values.length === 0) {
  types[col] = "TEXT";
  continue;
}

Mixed Number Formats

The escaper normalizes comma decimals:

const normalized = v.replace(",", ".");

"1,234.56" stays as-is. "1.234,56" (EU format) should be normalized before reaching the SQL generator—that's the job of the cleaning presets.

Very Long Values

TEXT columns in SQLite/PostgreSQL handle arbitrary length. No truncation needed. For MySQL's VARCHAR limits, you'd need to specify length or use TEXT explicitly.

Database Compatibility

The generated SQL is intentionally simple:

Feature	SQLite	PostgreSQL	MySQL
CREATE TABLE	✅	✅	✅
INTEGER/REAL/TEXT	✅	✅	✅
Multi-row INSERT	✅	✅	✅
Single quote escape	✅	✅	✅

For database-specific features (constraints, indexes, schemas), you'd extend the generator. For basic data import, this works everywhere.

Using the Export

# SQLite
sqlite3 mydb.db < export.sql

# PostgreSQL
psql -d mydb -f export.sql

# MySQL
mysql mydb < export.sql

Or paste directly into your database client.

For more on the CSV export path (when you don't need SQL), see our guide on exporting HTML tables to CSV.

Need SQL exports without writing code? Learn more at gauchogrid.com/html-table-exporter or try it free on the Chrome Web Store.

5 Tablas de Wikipedia que Rompen la Mayoría de los Scrapers (Y Cómo Solucionarlo)

circobit — Wed, 24 Jun 2026 13:30:00 +0000

Wikipedia es la fuente más común de datos tabulares web. También es un campo minado de casos extremos que rompen los scrapers ingenuos.

Recopilé los cinco patrones que más problemas causan mientras construía HTML Table Exporter, con código de detección y soluciones para cada uno.

Patrón 1: Filas de Navegación ("v t e")

El problema:

<table>
  <tr>
    <td colspan="5">v t e Países por población</td>
  </tr>
  <tr>
    <td>Rango</td><td>País</td><td>Población</td>...
  </tr>
  ...
</table>

La primera fila contiene enlaces "v t e" (Ver/Discusión/Editar) a páginas de plantillas de Wikipedia. Si tu scraper trata la fila 0 como encabezados, todo se rompe.

Lo que produce pd.read_html:

          v t e Países por población
0   Rango                        País    ...
1       1                       China    ...

Detección:

def is_nav_row(row_values):
    """Detectar prefijo de navegación de Wikipedia."""
    if not row_values:
        return False

    first_cell = str(row_values[0]).strip().lower()
    patterns = [
        r'^v\s+t\s+e\s',        # "v t e "
        r'^v\s*\|\s*t\s*\|\s*e', # "v | t | e"
        r'^\[v\]\s*\[t\]\s*\[e\]' # "[v] [t] [e]"
    ]

    import re
    return any(re.match(p, first_cell) for p in patterns)

Solución:

import pandas as pd

def read_wikipedia_table(url, table_index=0):
    tables = pd.read_html(url)
    df = tables[table_index]

    # Verificar si la primera fila es de navegación
    if is_nav_row(df.iloc[0].values):
        # Usar la segunda fila como encabezado
        df.columns = df.iloc[1]
        df = df.iloc[2:].reset_index(drop=True)

    return df

Patrón 2: Tablas Duplicadas Horizontalmente

El problema:

Para ahorrar espacio vertical, Wikipedia muestra algunas tablas en múltiples columnas:

| Rango | Nombre | Pob  | Rango | Nombre  | Pob  |
|-------|--------|------|-------|---------|------|
| 1     | Tokio  | 37M  | 11    | París   | 11M  |
| 2     | Delhi  | 32M  | 12    | Cairo   | 10M  |

Esto es lógicamente UNA tabla con estructura de columnas repetida.

Lo que produce pd.read_html:

   Rango  Nombre  Pob  Rango.1  Nombre.1  Pob.1
0      1   Tokio  37M       11     París    11M
1      2   Delhi  32M       12     Cairo    10M

Pandas lo ve como 6 columnas. Si filtras por "Nombre", te pierdes la mitad de los datos.

Detección:

def detect_horizontal_duplication(columns):
    """Verificar si las columnas se repiten (Rango, Nombre, Pob, Rango, Nombre, Pob)."""
    cols = list(columns)
    n = len(cols)

    # Intentar dividir por 2, 3, 4
    for divisor in [2, 3, 4]:
        if n % divisor != 0:
            continue

        chunk_size = n // divisor
        base_pattern = [c.rstrip('.0123456789') for c in cols[:chunk_size]]

        is_duplicate = True
        for i in range(1, divisor):
            chunk = cols[i * chunk_size : (i + 1) * chunk_size]
            normalized = [c.rstrip('.0123456789') for c in chunk]
            if normalized != base_pattern:
                is_duplicate = False
                break

        if is_duplicate:
            return chunk_size

    return None

Solución:

def normalize_duplicated_table(df, base_columns):
    """Apilar tablas duplicadas horizontalmente de forma vertical."""
    n_repeats = len(df.columns) // base_columns

    frames = []
    for i in range(n_repeats):
        start = i * base_columns
        end = start + base_columns
        chunk = df.iloc[:, start:end].copy()
        chunk.columns = df.columns[:base_columns]
        # Eliminar filas donde todos los valores son NaN (segunda mitad vacía)
        chunk = chunk.dropna(how='all')
        frames.append(chunk)

    return pd.concat(frames, ignore_index=True)

# Uso
df = pd.read_html(url)[0]
chunk_size = detect_horizontal_duplication(df.columns)
if chunk_size:
    df = normalize_duplicated_table(df, chunk_size)

Patrón 3: Filas de Título (Abarcando Todas las Columnas)

El problema:

<table>
  <tr>
    <td colspan="4">Lista de los edificios más altos del mundo</td>
  </tr>
  <tr>
    <td>Rango</td><td>Edificio</td><td>Ciudad</td><td>Altura</td>
  </tr>
  ...
</table>

La primera fila es un título, no datos. Después de la expansión de colspan, se convierte en:

['Lista de los más altos...', 'Lista de los más altos...', 'Lista de los más altos...', 'Lista de los más altos...']

Detección:

def is_title_row(row_values, next_row_values):
    """Detectar filas de título de ancho completo."""
    if not row_values or not next_row_values:
        return False

    # Todos los valores son iguales (colspan expandido)
    unique_values = set(str(v).strip() for v in row_values if str(v).strip())

    # Fila de título: 1 valor único, la siguiente fila tiene múltiples valores únicos
    # Y el valor es largo (> 20 caracteres típicamente para títulos)
    if len(unique_values) == 1:
        title = list(unique_values)[0]
        next_unique = len(set(str(v).strip() for v in next_row_values if str(v).strip()))
        return len(title) > 20 and next_unique > 2

    return False

Solución:

def skip_title_rows(df):
    """Eliminar filas de título del inicio de un dataframe."""
    skip_count = 0

    for i in range(min(3, len(df) - 1)):
        current_row = df.iloc[i].values
        next_row = df.iloc[i + 1].values if i + 1 < len(df) else None

        if is_title_row(current_row, next_row):
            skip_count = i + 1
        else:
            break

    if skip_count > 0:
        # Usar la fila después de los títulos como encabezado
        df.columns = df.iloc[skip_count]
        df = df.iloc[skip_count + 1:].reset_index(drop=True)

    return df

Patrón 4: Encabezados Agrupados (Dos Niveles)

El problema:

|        |         | Estadísticas      | Estadísticas     |
| Rango  | País    | PIB (nominal)     | PIB (PPA)        |
|--------|---------|-------------------|------------------|
| 1      | EEUU    | 25.5 billones     | 25.5 billones    |

La fila 0 son encabezados de categoría. La fila 1 son los encabezados reales de columna. Ambas son semánticamente "encabezados."

Lo que produce pd.read_html:

Frecuentemente corrupto o con MultiIndex incómodo de manejar.

Detección:

def has_grouped_headers(df):
    """Detectar encabezados agrupados de dos niveles."""
    if len(df) < 3:
        return False

    row0 = df.iloc[0].values
    row1 = df.iloc[1].values

    # Contar valores consecutivos repetidos en row0
    repeat_count = 0
    for i in range(1, len(row0)):
        if str(row0[i]).strip() == str(row0[i-1]).strip() and str(row0[i]).strip():
            repeat_count += 1

    repeat_ratio = repeat_count / max(1, len(row0) - 1)

    # Los encabezados agrupados típicamente tienen 40%+ de valores repetidos
    # Y row1 tiene más valores únicos no vacíos que row0
    unique0 = len(set(str(v).strip() for v in row0 if str(v).strip()))
    unique1 = len(set(str(v).strip() for v in row1 if str(v).strip()))

    return repeat_ratio > 0.3 and unique1 > unique0

Solución:

def merge_grouped_headers(df):
    """Combinar encabezados de dos niveles en uno solo."""
    group_row = df.iloc[0].values
    header_row = df.iloc[1].values

    merged = []
    for i, (group, header) in enumerate(zip(group_row, header_row)):
        g = str(group).strip()
        h = str(header).strip()

        if not g or g == h:
            merged.append(h)
        elif not h:
            merged.append(g)
        else:
            merged.append(f"{g} - {h}")

    df.columns = merged
    return df.iloc[2:].reset_index(drop=True)

# Uso
if has_grouped_headers(df):
    df = merge_grouped_headers(df)

Patrón 5: Tablas Anidadas en Infoboxes

El problema:

Los infoboxes de Wikipedia contienen tablas dentro de celdas de tabla:

<table class="infobox">
  <tr>
    <td>Población</td>
    <td>
      <table>  <!-- ¡Anidada! -->
        <tr><td>Urbana</td><td>8.3M</td></tr>
        <tr><td>Metro</td><td>20.1M</td></tr>
      </table>
    </td>
  </tr>
</table>

Lo que produce pd.read_html:

Tanto la tabla externa como la interna son devueltas. Si buscas "todas las tablas de la página", obtienes duplicados y basura anidada.

Detección y Filtrado:

from bs4 import BeautifulSoup
import requests

def get_top_level_tables(url):
    """Obtener solo tablas de nivel superior, no anidadas."""
    response = requests.get(url)
    soup = BeautifulSoup(response.text, 'html.parser')

    all_tables = soup.find_all('table')

    top_level = []
    for table in all_tables:
        # Verificar si esta tabla está dentro de otra tabla
        parent = table.parent
        is_nested = False

        while parent:
            if parent.name == 'table':
                is_nested = True
                break
            parent = parent.parent

        if not is_nested:
            top_level.append(table)

    return top_level

def read_top_level_tables(url):
    """Leer solo tablas de nivel superior como DataFrames."""
    import pandas as pd

    tables = get_top_level_tables(url)

    dfs = []
    for table in tables:
        try:
            # Convertir tabla individual a DataFrame
            df = pd.read_html(str(table))[0]
            dfs.append(df)
        except Exception:
            continue

    return dfs

Lector Completo de Tablas de Wikipedia

Combinando todas las soluciones:

import pandas as pd
import requests
from bs4 import BeautifulSoup
import re

class WikipediaTableReader:
    def __init__(self, url):
        self.url = url
        self.soup = None

    def _fetch(self):
        if self.soup is None:
            response = requests.get(self.url)
            self.soup = BeautifulSoup(response.text, 'html.parser')

    def _is_nav_row(self, values):
        if not values:
            return False
        first = str(values[0]).strip().lower()
        return bool(re.match(r'^v\s+t\s+e\s', first))

    def _is_title_row(self, values, next_values):
        unique = set(str(v).strip() for v in values if str(v).strip())
        if len(unique) != 1:
            return False
        title = list(unique)[0]
        next_unique = len(set(str(v).strip() for v in next_values if str(v).strip()))
        return len(title) > 20 and next_unique > 2

    def get_tables(self, skip_infobox=True):
        """Obtener todas las tablas de datos de la página."""
        self._fetch()

        tables = self.soup.find_all('table')
        results = []

        for table in tables:
            # Saltar tablas anidadas
            if table.find_parent('table'):
                continue

            # Saltar infoboxes si se solicita
            if skip_infobox and 'infobox' in table.get('class', []):
                continue

            try:
                df = pd.read_html(str(table))[0]
                df = self._clean_table(df)
                if len(df) > 0 and len(df.columns) > 1:
                    results.append(df)
            except Exception:
                continue

        return results

    def _clean_table(self, df):
        """Aplicar todos los pasos de limpieza."""
        # Saltar filas de navegación
        while len(df) > 0 and self._is_nav_row(df.iloc[0].values):
            df.columns = df.iloc[1] if len(df) > 1 else df.columns
            df = df.iloc[2:].reset_index(drop=True) if len(df) > 2 else df.iloc[1:]

        # Saltar filas de título
        if len(df) > 1:
            while self._is_title_row(df.iloc[0].values, df.iloc[1].values if len(df) > 1 else []):
                df.columns = df.iloc[1]
                df = df.iloc[2:].reset_index(drop=True)

        return df

# Uso
reader = WikipediaTableReader("https://es.wikipedia.org/wiki/Anexo:Países_por_población")
tables = reader.get_tables()

Cuándo Usar una Extensión en su Lugar

Si estás haciendo extracción ad-hoc (no construyendo un pipeline), una extensión de navegador maneja todos estos patrones automáticamente.

HTML Table Exporter detecta estos patrones y normaliza la salida. Un clic vs. debuggear casos extremos.

Para un tutorial práctico, mira nuestra guía sobre las mejores extensiones de Chrome para exportar tablas.

Para pipelines automatizados, usa el código de arriba. Para exportaciones ocasionales, usa la herramienta correcta para el trabajo.

Más información en gauchogrid.com/es/html-table-exporter o pruébalo gratis en la Chrome Web Store.

¿Encontraste una tabla de Wikipedia que rompe este código? Comparte la URL—la voy a agregar a mi suite de tests.

HTMLテーブルからSQL INSERT文をワンクリックで生成する方法

circobit — Wed, 24 Jun 2026 00:00:00 +0000

Webサイトでデータを見つけた。データベースに入れたい。通常のワークフロー：CSVにエクスポート → SQLツールにインポート → 型の不一致に対処 → エンコーディング問題を修正。

HTMLテーブルから直接、有効なSQLを生成できたらどうでしょう？

このガイドでは、型推論、識別子のサニタイズ、適切なエスケープ処理を含め、任意のWebテーブルから CREATE TABLE と INSERT INTO 文を生成する方法を説明します。これはHTML Table Exporterで使用しているアプローチです。

最終結果

このようなテーブルから：

| Product Name    | Price  | In Stock |
|-----------------|--------|----------|
| Widget Pro      | 29.99  | Yes      |
| Gadget Basic    | 14.50  | No       |

以下を生成：

-- Exported from HTML Table Exporter PRO

CREATE TABLE products (
  product_name TEXT,
  price REAL,
  in_stock TEXT
);

INSERT INTO products (product_name, price, in_stock) VALUES
  ('Widget Pro', 29.99, 'Yes'),
  ('Gadget Basic', 14.50, 'No');

ステップバイステップで構築していきましょう。

ステップ1: テーブルマトリクスの抽出

まず、HTMLテーブルから生データを抽出します：

function extractTableMatrix(table) {
  const rows = Array.from(table.rows);
  const grid = [];

  rows.forEach((rowEl, rowIndex) => {
    if (!grid[rowIndex]) grid[rowIndex] = [];
    let colIndex = 0;

    Array.from(rowEl.cells).forEach(cell => {
      while (grid[rowIndex][colIndex] !== undefined) colIndex++;

      const text = cell.textContent.trim();
      const rowSpan = parseInt(cell.rowSpan) || 1;
      const colSpan = parseInt(cell.colSpan) || 1;

      for (let r = 0; r < rowSpan; r++) {
        if (!grid[rowIndex + r]) grid[rowIndex + r] = [];
        for (let c = 0; c < colSpan; c++) {
          grid[rowIndex + r][colIndex + c] = text;
        }
      }
      colIndex += colSpan;
    });
  });

  return grid;
}

ステップ2: カラム名のサニタイズ

SQL識別子には厳格なルールがあります。"Product Name" や "Price ($)" のようなヘッダーにはサニタイズが必要です：

function sanitizeSqlIdentifier(header, fallbackIndex) {
  let id = (header || "").toString().trim();

  if (!id) {
    return `col_${fallbackIndex + 1}`;
  }

  // Unicodeを正規化（アクセント除去）
  id = id.normalize("NFD").replace(/[\u0300-\u036f]/g, "");

  // 小文字のsnake_caseに変換
  id = id
    .toLowerCase()
    .replace(/[^a-z0-9]+/g, "_")
    .replace(/^_+|_+$/g, "");

  // 数字で始まらないことを確認
  if (/^\d/.test(id)) {
    id = `col_${id}`;
  }

  if (!id) {
    return `col_${fallbackIndex + 1}`;
  }

  return id;
}

// 例:
// "Product Name" → "product_name"
// "Price ($)"    → "price"
// "2024 Revenue" → "col_2024_revenue"
// ""             → "col_1"

ステップ3: 重複カラム名の処理

テーブルに重複ヘッダーがある場合があります。SQLは一意のカラム名を要求します：

function makeUniqueColumnNames(headers) {
  const used = new Set();

  return headers.map((header, idx) => {
    let name = sanitizeSqlIdentifier(header, idx);
    let candidate = name;
    let counter = 1;

    while (used.has(candidate)) {
      candidate = `${name}_${counter}`;
      counter++;
    }

    used.add(candidate);
    return candidate;
  });
}

// ["Name", "Name", "Value"] → ["name", "name_1", "value"]

ステップ4: SQL型の推論

データを分析して適切なSQL型を決定：

function inferSqlColumnTypes(rows, headerRowIndex = 0) {
  const headerRow = rows[headerRowIndex] || [];
  const dataRows = rows.slice(headerRowIndex + 1);
  const types = new Array(headerRow.length).fill("TEXT");

  for (let col = 0; col < headerRow.length; col++) {
    const values = [];
    for (let r = 0; r < Math.min(dataRows.length, 50); r++) {
      const cell = dataRows[r][col];
      const v = cell != null ? String(cell).trim() : "";
      if (v !== "") values.push(v);
    }

    if (values.length === 0) {
      types[col] = "TEXT";
      continue;
    }

    let allInt = true;
    let allNumeric = true;

    for (const v of values) {
      if (!/^[-+]?\d+$/.test(v)) allInt = false;
      if (!/^[-+]?\d+([.,]\d+)?$/.test(v)) allNumeric = false;
    }

    if (allInt) types[col] = "INTEGER";
    else if (allNumeric) types[col] = "REAL";
    else types[col] = "TEXT";
  }

  return types;
}

型の優先順位: INTEGER > REAL > TEXT

ステップ5: 値の適切なエスケープ

SQLインジェクションはセキュリティの問題だけでなく、データの破損にもつながります。適切なエスケープ：

function sqlEscapeValue(raw, type) {
  if (raw == null) return "NULL";

  const v = String(raw).trim();
  if (v === "") return "NULL";

  if (type === "INTEGER" || type === "REAL") {
    const normalized = v.replace(",", ".");
    const num = Number(normalized);

    if (!Number.isNaN(num) && Number.isFinite(num)) {
      return normalized;
    }
  }

  // TEXT: シングルクォートを二重にしてエスケープ
  const escaped = v.replace(/'/g, "''");
  return `'${escaped}'`;
}

// 例:
// sqlEscapeValue("Hello", "TEXT")       → "'Hello'"
// sqlEscapeValue("It's good", "TEXT")   → "'It''s good'"
// sqlEscapeValue("29.99", "REAL")       → "29.99"
// sqlEscapeValue("", "TEXT")            → "NULL"
// sqlEscapeValue(null, "TEXT")          → "NULL"

ステップ6: SQLの生成

すべてを組み合わせて：

function tableToSql(tableInfo) {
  const rows = tableInfo.rows || [];
  if (rows.length < 2) return "";

  const headerRowIndex = tableInfo.headerRowIndex || 0;
  const headerRow = rows[headerRowIndex];
  const dataRows = rows.slice(headerRowIndex + 1);

  if (!headerRow || headerRow.length === 0) return "";

  const columnNames = makeUniqueColumnNames(headerRow);
  const types = inferSqlColumnTypes(rows, headerRowIndex);

  const rawTableName = tableInfo.name || tableInfo.slug || "table";
  const tableName = sanitizeSqlIdentifier(rawTableName, 0) || "table_export";

  // CREATE TABLE文
  const createLines = columnNames.map((col, i) => 
    `  ${col} ${types[i] || "TEXT"}`
  );
  const createStmt = `CREATE TABLE ${tableName} (\n${createLines.join(",\n")}\n);`;

  // INSERT文
  const insertHeader = `INSERT INTO ${tableName} (${columnNames.join(", ")}) VALUES`;

  const valueLines = dataRows.map(row => {
    const values = columnNames.map((_, i) => {
      const cell = row[i];
      const type = types[i] || "TEXT";
      return sqlEscapeValue(cell, type);
    });
    return `  (${values.join(", ")})`;
  });

  let sql = `-- Exported from HTML Table Exporter\n\n${createStmt}\n\n`;

  if (valueLines.length > 0) {
    sql += `${insertHeader}\n${valueLines.join(",\n")};\n`;
  }

  return sql;
}

エッジケースの処理

NULL値

Webテーブルは欠損データを様々な方法で表現します：

const NULL_PATTERNS = ["N/A", "n/a", "-", "--", "null", "none", "."];

function sqlEscapeValue(raw, type, nullPatterns = NULL_PATTERNS) {
  if (raw == null) return "NULL";

  const v = String(raw).trim();
  if (v === "" || nullPatterns.includes(v.toLowerCase())) {
    return "NULL";
  }
  // ... 残りの関数
}

大規模データセット

数千行のテーブルにはINSERTをバッチ処理：

function tableToSqlBatched(tableInfo, batchSize = 1000) {
  // ... 同じセットアップ ...

  const batches = [];
  for (let i = 0; i < valueLines.length; i += batchSize) {
    const batch = valueLines.slice(i, i + batchSize);
    batches.push(`${insertHeader}\n${batch.join(",\n")};`);
  }

  return `${createStmt}\n\n${batches.join("\n\n")}`;
}

データベース固有の構文

SQLite、PostgreSQL、MySQLにはわずかな構文の違いがあります：

function tableToSql(tableInfo, dialect = "sqlite") {
  const typeMap = {
    sqlite: { INTEGER: "INTEGER", REAL: "REAL", TEXT: "TEXT" },
    postgresql: { INTEGER: "INTEGER", REAL: "NUMERIC", TEXT: "TEXT" },
    mysql: { INTEGER: "INT", REAL: "DECIMAL(10,2)", TEXT: "VARCHAR(255)" }
  };

  const dialectTypes = typeMap[dialect] || typeMap.sqlite;
  // ...
}

いつ使うべきか

適している場合:

SQLite/PostgreSQLへの素早いデータインポート
テストデータベースのシード
一回限りのデータ移行
例を通じてSQLを学ぶ

不向きな場合:

大規模ETL（専用ツールを使用）
複雑なスキーマ（外部キー、制約）
バイナリデータ

コード不要で試す

自分で構築したくない場合、HTML Table Exporter PROがワンクリックでSQLを生成します。無料版はCSV/JSON/Excelにエクスポートでき、PROではSQL、NDJSON、データクリーニングが追加されます。

エクスポートアプローチの比較については、テーブルエクスポートに最適なChrome拡張機能トップ5のガイドをご覧ください。

詳しくは gauchogrid.com/ja/html-table-exporter をご覧いただくか、Chrome Web Store でお試しください。

Webデータをどのデータベースにインポートしていますか？ユースケースに興味があります。

Web Scraping vs. Browser-Extensions – Wann welches Tool für die Datenextraktion?

circobit — Tue, 23 Jun 2026 07:30:00 +0000

Sie brauchen Daten von einer Website. Schreiben Sie einen Python-Scraper? Starten Sie Playwright? Nutzen Sie eine Browser-Erweiterung? Nach der Datenextraktion von Hunderten verschiedener Websites habe ich ein Framework für die Wahl des richtigen Tools entwickelt.

Die Optionen

Ansatz	Läuft	JS-fähig	Login-Unterstützung	Setup-Zeit
Python + requests	Server	❌	Manuelle Cookies	5 Min
Python + BeautifulSoup	Server	❌	Manuelle Cookies	5 Min
Playwright/Puppeteer	Server	✅	Skriptbar	15 Min
Browser-Erweiterung	Browser des Nutzers	✅	Automatisch	0 Min
Copy-Paste	Browser des Nutzers	✅	Automatisch	0 Min

Jeder Ansatz hat Vor- und Nachteile. Schauen wir sie uns im Detail an.

Option 1: Python + Requests/BeautifulSoup

Am besten für: Statische HTML-Seiten, APIs, automatisierte Pipelines

import requests
from bs4 import BeautifulSoup

response = requests.get("https://example.com/data")
soup = BeautifulSoup(response.text, "html.parser")

table = soup.find("table")
rows = []
for tr in table.find_all("tr"):
    row = [td.get_text(strip=True) for td in tr.find_all(["td", "th"])]
    rows.append(row)

Vorteile:

Schnelle Ausführung
Einfach planbar (cron, Airflow)
Kein Browser-Overhead

Einschränkungen:

Führt kein JavaScript aus
Viele moderne Websites rendern Tabellen clientseitig
Authentifizierung erfordert manuelles Cookie-Handling

Wann es scheitert: Versuchen Sie, ein React-basiertes Dashboard zu scrapen. Das HTML, das Sie erhalten, ist ein leeres <div id="root"></div>.

Option 2: Headless Browser (Playwright/Puppeteer)

Am besten für: JavaScript-gerenderte Seiten, automatisierte Pipelines, Seiten die Interaktion erfordern

const { chromium } = require('playwright');

(async () => {
  const browser = await chromium.launch();
  const page = await browser.newPage();
  await page.goto('https://example.com/dashboard');

  // Warten bis die Tabelle gerendert ist
  await page.waitForSelector('table');

  const data = await page.evaluate(() => {
    const table = document.querySelector('table');
    return Array.from(table.rows).map(row =>
      Array.from(row.cells).map(cell => cell.textContent.trim())
    );
  });

  console.log(data);
  await browser.close();
})();

Vorteile:

Führt JavaScript aus
Kann mit Seiten interagieren (Klicks, Scrollen, Formulare)
Skriptbare Authentifizierungs-Flows

Einschränkungen:

Langsamer als direktes HTTP
Ressourcenintensiv (Speicher, CPU)
Komplexeres Error-Handling
Websites können Headless-Browser erkennen

Wann es scheitert: Viele Websites erkennen Puppeteer/Playwright über Navigator-Eigenschaften, WebGL-Fingerprinting oder Verhaltensanalyse. Stealth-Plugins helfen, sind aber nicht narrensicher.

Option 3: Browser-Erweiterungen

Am besten für: Ad-hoc-Extraktion, authentifizierte Websites, nutzergesteuerte Workflows

Eine Browser-Erweiterung läuft in der tatsächlichen Browser-Sitzung des Nutzers, mit vollem Zugriff auf:

Authentifizierte Sitzungen
JavaScript-gerenderte Inhalte
Exakt das DOM, das der Nutzer sieht

Einen Vergleich der besten Optionen finden Sie unter Die 5 besten Chrome-Erweiterungen zum Exportieren von Tabellen (2026).

// Content-Script in einer Chrome-Erweiterung
chrome.runtime.onMessage.addListener((msg, sender, sendResponse) => {
  if (msg.type === "EXTRACT_TABLE") {
    const table = document.querySelector("table");
    const data = Array.from(table.rows).map(row =>
      Array.from(row.cells).map(cell => cell.textContent.trim())
    );
    sendResponse({ data });
  }
});

Vorteile:

Null Authentifizierungs-Aufwand – Sie sind bereits eingeloggt
Sieht genau das, was Sie sehen (keine JS-Rendering-Probleme)
Funktioniert auf jeder Website (keine Bot-Erkennung)
Keine Server-Infrastruktur nötig

Einschränkungen:

Erfordert manuelle Auslösung (Nutzer klickt)
Kann nicht zeitgesteuert laufen
Auf den Browser-Kontext beschränkt

Wann es scheitert: Sie müssen Daten von 10.000 Seiten automatisch extrahieren. Erweiterungen sind für nutzergesteuerte Workflows, nicht für Batch-Verarbeitung.

Entscheidungs-Framework

Python + requests verwenden, wenn:

✅ Die Seite servergerendertes HTML liefert
✅ Sie automatisierte/geplante Extraktion brauchen
✅ Sie eine Datenpipeline aufbauen
✅ Die Authentifizierung über API-Schlüssel oder einfache Cookies läuft

Playwright/Puppeteer verwenden, wenn:

✅ Die Seite JavaScript-Rendering erfordert
✅ Sie automatisierte/geplante Extraktion brauchen
✅ Sie interagieren müssen (scrollen, klicken, paginieren)
✅ Sie Bot-Erkennungs-Gegenmaßnahmen handhaben können

Eine Browser-Erweiterung verwenden, wenn:

✅ Sie bereits auf der Website eingeloggt sind
✅ Sie Daten gelegentlich brauchen (nicht automatisiert)
✅ Die Website starke Bot-Erkennung hat
✅ Sie Daten JETZT wollen, ohne Code zu schreiben

Einfach Copy-Paste, wenn:

✅ Einmalige Extraktion
✅ Einfache Tabellenstruktur
✅ Kein bestimmtes Format nötig

Praxisbeispiele

Beispiel 1: Wikipedia-Tabellen

Bester Ansatz: Browser-Erweiterung oder Python

Wikipedia liefert servergerendertes HTML ohne Authentifizierung. Python funktioniert einwandfrei:

import pandas as pd

url = "https://de.wikipedia.org/wiki/Liste_der_Staaten_der_Erde"
tables = pd.read_html(url)
df = tables[0]

Aber Wikipedia-Tabellen haben oft komplexe Rowspans und Navigationszeilen. Eine spezialisierte Erweiterung behandelt diese automatisch.

Eine Schritt-für-Schritt-Anleitung finden Sie unter Alle Zeilen einer paginierten Webtabelle exportieren.

Beispiel 2: Finanz-Dashboard (hinter Login)

Bester Ansatz: Browser-Erweiterung

Ihr Broker zeigt Portfoliodaten nach dem Login an. Optionen:

Python: Den Authentifizierungs-Flow reverse-engineeren, 2FA handhaben, Session-Cookies pflegen. Möglich, aber fragil.
Playwright: Den Login skripten, 2FA-Prompts behandeln, zu den Daten navigieren. Funktioniert, aber komplex.
Erweiterung: Normal einloggen, „Tabelle exportieren" klicken. Fertig.

Für gelegentliche Exporte gewinnt die Erweiterung bei der Zeit bis zur Datenbereitstellung.

Beispiel 3: Tägliches Preis-Monitoring (1000 Seiten)

Bester Ansatz: Playwright + Queue

Sie müssen täglich Preise auf 1000 Produktseiten prüfen. Das erfordert:

// Pseudocode für Batch-Extraktion
const urls = loadUrlsFromDatabase();

for (const url of urls) {
  const page = await browser.newPage();
  await page.goto(url);
  await page.waitForSelector('.price');

  const price = await page.evaluate(() =>
    document.querySelector('.price').textContent
  );

  await saveToDatabase(url, price);
  await page.close();

  // Rate-Limiting
  await sleep(randomBetween(1000, 3000));
}

Erweiterungen können das nicht – sie erfordern Nutzerinteraktion. Playwright ist das richtige Tool.

Beispiel 4: Einmalige Sport-Statistiken exportieren

Bester Ansatz: Browser-Erweiterung

FBRef hat komplexe zweistufige Überschriften. Sie brauchen die Statistiken dieser Saison einmal.

Python-Ansatz: 30 Minuten, um einen eigenen Parser für deren Tabellenstruktur zu schreiben.

Erweiterungs-Ansatz: Export klicken. 10 Sekunden.

Für einmalige Extraktion nicht über-engineeren.

Hybride Ansätze

Manchmal braucht man beides:

Erweiterung nutzen, um Authentifizierungs-Cookies zu exportieren
- Cookies aus einer eingeloggten Sitzung exportieren
- In Python/Playwright für Automatisierung importieren
Erweiterung zum Inspizieren der Struktur, Python zum Skalieren
- DOM mit den Erweiterungs-Tools manuell untersuchen
- Einen gezielten Scraper schreiben, sobald man die Struktur versteht
Playwright für Navigation, Erweiterung für Extraktion
- Skript navigiert zur Seite
- Ruft die Erweiterungs-API für komplexes Tabellen-Parsing auf

Mein Stack

Für die 80 % der Fälle, in denen ich Web-Tabellendaten brauche:

Einmalig, authentifiziert: HTML Table Exporter (Browser-Erweiterung, die ich gebaut habe)
Einmalig, öffentliche Daten: pd.read_html() oder Erweiterung
Automatisierte Pipeline: Playwright mit eigenen Parsern
API verfügbar: Direkte API-Aufrufe (immer bevorzugt)

Das beste Tool hängt von der konkreten Extraktion ab. Passen Sie die Komplexität Ihrer Lösung an die Komplexität Ihres Problems an.

Was ist Ihr bevorzugter Extraktions-Ansatz? Mehr erfahren auf gauchogrid.com/de/html-table-exporter oder die Erweiterung kostenlos im Chrome Web Store testen.

HTML 테이블에서 SQL INSERT 문까지 원클릭으로

circobit — Tue, 23 Jun 2026 00:30:00 +0000

웹사이트에서 데이터를 찾았습니다. 데이터베이스에 넣어야 합니다. 보통 워크플로우는: CSV로 내보내기, SQL 도구에 임포트, 타입 불일치 처리, 인코딩 문제 수정.

HTML 테이블에서 바로 유효한 SQL을 생성할 수 있다면 어떨까요?

이 가이드에서는 모든 웹 테이블에서 CREATE TABLE 및 INSERT INTO 문을 생성하는 방법을 타입 추론, 식별자 정제, 적절한 이스케이프 처리와 함께 보여줍니다. HTML Table Exporter에서 사용하는 접근법입니다.

최종 결과

이런 테이블에서:

| Product Name    | Price  | In Stock |
|-----------------|--------|----------|
| Widget Pro      | 29.99  | Yes      |
| Gadget Basic    | 14.50  | No       |

이렇게 생성:

-- Exported from HTML Table Exporter PRO

CREATE TABLE products (
  product_name TEXT,
  price REAL,
  in_stock TEXT
);

INSERT INTO products (product_name, price, in_stock) VALUES
  ('Widget Pro', 29.99, 'Yes'),
  ('Gadget Basic', 14.50, 'No');

단계별로 구축해봅시다.

1단계: 테이블 매트릭스 추출

먼저 HTML 테이블에서 원시 데이터를 추출합니다:

function extractTableMatrix(table) {
  const rows = Array.from(table.rows);
  const grid = [];

  rows.forEach((rowEl, rowIndex) => {
    if (!grid[rowIndex]) grid[rowIndex] = [];
    let colIndex = 0;

    Array.from(rowEl.cells).forEach(cell => {
      while (grid[rowIndex][colIndex] !== undefined) colIndex++;

      const text = cell.textContent.trim();
      const rowSpan = parseInt(cell.rowSpan) || 1;
      const colSpan = parseInt(cell.colSpan) || 1;

      for (let r = 0; r < rowSpan; r++) {
        if (!grid[rowIndex + r]) grid[rowIndex + r] = [];
        for (let c = 0; c < colSpan; c++) {
          grid[rowIndex + r][colIndex + c] = text;
        }
      }
      colIndex += colSpan;
    });
  });

  return grid;
}

출력: rows[0]이 헤더이고 rows[1+]이 데이터인 2D 배열.

2단계: 컬럼명 정제

SQL 식별자에는 엄격한 규칙이 있습니다. "Product Name"이나 "Price ($)" 같은 헤더는 정제가 필요합니다:

function sanitizeSqlIdentifier(header, fallbackIndex) {
  let id = (header || "").toString().trim();

  if (!id) {
    return `col_${fallbackIndex + 1}`;
  }

  // 유니코드 정규화 (악센트 제거)
  id = id.normalize("NFD").replace(/[\u0300-\u036f]/g, "");

  // 소문자 snake_case 변환
  id = id
    .toLowerCase()
    .replace(/[^a-z0-9]+/g, "_")
    .replace(/^_+|_+$/g, "");

  // 숫자로 시작하지 않도록
  if (/^\d/.test(id)) {
    id = `col_${id}`;
  }

  // 정제 후 비어있으면 폴백
  if (!id) {
    return `col_${fallbackIndex + 1}`;
  }

  return id;
}

// 예시:
// "Product Name" → "product_name"
// "Price ($)"    → "price"
// "2024 Revenue" → "col_2024_revenue"
// ""             → "col_1"

3단계: 중복 컬럼명 처리

테이블에 중복 헤더가 있을 수 있습니다. SQL은 고유한 컬럼명을 요구합니다:

function makeUniqueColumnNames(headers) {
  const used = new Set();

  return headers.map((header, idx) => {
    let name = sanitizeSqlIdentifier(header, idx);
    let candidate = name;
    let counter = 1;

    while (used.has(candidate)) {
      candidate = `${name}_${counter}`;
      counter++;
    }

    used.add(candidate);
    return candidate;
  });
}

// ["Name", "Name", "Value"] → ["name", "name_1", "value"]

4단계: SQL 타입 추론

데이터를 분석하여 적절한 SQL 타입 결정:

function inferSqlColumnTypes(rows, headerRowIndex = 0) {
  const headerRow = rows[headerRowIndex] || [];
  const dataRows = rows.slice(headerRowIndex + 1);
  const types = new Array(headerRow.length).fill("TEXT");

  for (let col = 0; col < headerRow.length; col++) {
    // 컬럼당 최대 50개 값 샘플링
    const values = [];
    for (let r = 0; r < Math.min(dataRows.length, 50); r++) {
      const cell = dataRows[r][col];
      const v = cell != null ? String(cell).trim() : "";
      if (v !== "") values.push(v);
    }

    if (values.length === 0) {
      types[col] = "TEXT";
      continue;
    }

    let allInt = true;
    let allNumeric = true;

    for (const v of values) {
      if (!/^[-+]?\d+$/.test(v)) {
        allInt = false;
      }
      if (!/^[-+]?\d+([.,]\d+)?$/.test(v)) {
        allNumeric = false;
      }
    }

    if (allInt) {
      types[col] = "INTEGER";
    } else if (allNumeric) {
      types[col] = "REAL";
    } else {
      types[col] = "TEXT";
    }
  }

  return types;
}

타입 우선순위: INTEGER > REAL > TEXT

5단계: 값 올바르게 이스케이프

SQL 인젝션은 보안 문제만이 아닙니다—데이터를 손상시킵니다. 적절한 이스케이프:

function sqlEscapeValue(raw, type) {
  // NULL 처리
  if (raw == null) return "NULL";

  const v = String(raw).trim();
  if (v === "") return "NULL";

  // 숫자 타입
  if (type === "INTEGER" || type === "REAL") {
    const normalized = v.replace(",", ".");
    const num = Number(normalized);

    if (!Number.isNaN(num) && Number.isFinite(num)) {
      return normalized;
    }
  }

  // TEXT: 작은따옴표를 두 배로 이스케이프
  const escaped = v.replace(/'/g, "''");
  return `'${escaped}'`;
}

// 예시:
// sqlEscapeValue("Hello", "TEXT")       → "'Hello'"
// sqlEscapeValue("It's good", "TEXT")   → "'It''s good'"
// sqlEscapeValue("29.99", "REAL")       → "29.99"
// sqlEscapeValue("", "TEXT")            → "NULL"
// sqlEscapeValue(null, "TEXT")          → "NULL"

6단계: SQL 생성

모든 것을 합치기:

function tableToSql(tableInfo) {
  const rows = tableInfo.rows || [];
  if (rows.length < 2) return "";

  const headerRowIndex = tableInfo.headerRowIndex || 0;
  const headerRow = rows[headerRowIndex];
  const dataRows = rows.slice(headerRowIndex + 1);

  if (!headerRow || headerRow.length === 0) return "";

  const columnNames = makeUniqueColumnNames(headerRow);
  const types = inferSqlColumnTypes(rows, headerRowIndex);

  const rawTableName = tableInfo.name || tableInfo.slug || "table";
  const tableName = sanitizeSqlIdentifier(rawTableName, 0) || "table_export";

  // CREATE TABLE 문
  const createLines = columnNames.map((col, i) => 
    `  ${col} ${types[i] || "TEXT"}`
  );
  const createStmt = `CREATE TABLE ${tableName} (\n${createLines.join(",\n")}\n);`;

  // INSERT 문
  const insertHeader = `INSERT INTO ${tableName} (${columnNames.join(", ")}) VALUES`;

  const valueLines = dataRows.map(row => {
    const values = columnNames.map((_, i) => {
      const cell = row[i];
      const type = types[i] || "TEXT";
      return sqlEscapeValue(cell, type);
    });
    return `  (${values.join(", ")})`;
  });

  let sql = `-- Exported from HTML Table Exporter\n\n${createStmt}\n\n`;

  if (valueLines.length > 0) {
    sql += `${insertHeader}\n${valueLines.join(",\n")};\n`;
  }

  return sql;
}

엣지 케이스 처리

NULL 값

많은 웹 테이블이 누락 데이터를 다르게 표현합니다:

const NULL_PATTERNS = ["N/A", "n/a", "-", "--", "null", "none", "."];

function sqlEscapeValue(raw, type, nullPatterns = NULL_PATTERNS) {
  if (raw == null) return "NULL";

  const v = String(raw).trim();
  if (v === "" || nullPatterns.includes(v.toLowerCase())) {
    return "NULL";
  }

  // ... 나머지 함수
}

대규모 데이터셋

수천 행이 있는 테이블에서는 INSERT를 배치 처리:

function tableToSqlBatched(tableInfo, batchSize = 1000) {
  // ... 같은 설정 ...

  const batches = [];
  for (let i = 0; i < valueLines.length; i += batchSize) {
    const batch = valueLines.slice(i, i + batchSize);
    batches.push(`${insertHeader}\n${batch.join(",\n")};`);
  }

  return `${createStmt}\n\n${batches.join("\n\n")}`;
}

데이터베이스별 구문

SQLite, PostgreSQL, MySQL에는 약간의 구문 차이가 있습니다:

function tableToSql(tableInfo, dialect = "sqlite") {
  // ... 같은 컬럼/타입 로직 ...

  const typeMap = {
    sqlite: { INTEGER: "INTEGER", REAL: "REAL", TEXT: "TEXT" },
    postgresql: { INTEGER: "INTEGER", REAL: "NUMERIC", TEXT: "TEXT" },
    mysql: { INTEGER: "INT", REAL: "DECIMAL(10,2)", TEXT: "VARCHAR(255)" }
  };

  const dialectTypes = typeMap[dialect] || typeMap.sqlite;

  const createLines = columnNames.map((col, i) => 
    `  ${col} ${dialectTypes[types[i]] || dialectTypes.TEXT}`
  );

  // ... 나머지 함수 ...
}

사용 시기

적합한 경우:

SQLite/PostgreSQL에 빠른 데이터 임포트
테스트 데이터베이스 시딩
일회성 데이터 마이그레이션
예시를 통한 SQL 학습

부적합한 경우:

대규모 ETL (전용 도구 사용)
복잡한 스키마 (외래 키, 제약 조건)
바이너리 데이터

프로덕션 데이터 파이프라인에는 검증 기능이 있는 적절한 ETL 도구가 낫습니다. "이 테이블을 지금 당장 데이터베이스에 넣어야 해"라면 직접 SQL 생성이 빠릅니다.

코드 없이 사용하기

직접 구축하고 싶지 않다면 HTML Table Exporter PRO가 원클릭으로 SQL을 생성합니다. 무료 버전은 CSV/JSON/Excel로 내보내기 가능하고, PRO는 SQL, NDJSON, 데이터 정제를 추가합니다.

다양한 내보내기 접근법의 비교는 HTML 테이블을 CSV로 내보내는 방법 가이드를 참고하세요.

gauchogrid.com/ko/html-table-exporter에서 자세히 알아보거나 Chrome 웹 스토어에서 사용해보세요.

어떤 데이터베이스에 웹 데이터를 임포트하고 계신가요? 사용 사례가 궁금합니다.

Van HTML-tabel naar SQL INSERT Statements in Eén Klik

circobit — Mon, 22 Jun 2026 12:30:00 +0000

Je hebt data op een website gevonden. Je hebt het in je database nodig. De workflow is meestal: exporteren naar CSV, importeren in SQL-tool, omgaan met type-mismatches, encoding-problemen oplossen.

Wat als je rechtstreeks van HTML-tabel naar geldige SQL kunt gaan?

Deze gids laat zien hoe je CREATE TABLE- en INSERT INTO-statements genereert uit elke webtabel, met type-inferentie, identifier-sanitisatie en correcte escaping. Dit is de aanpak die ik gebruik in HTML Table Exporter.

Het Eindresultaat

Van een tabel als deze:

| Productnaam     | Prijs  | Op Voorraad |
|-----------------|--------|-------------|
| Widget Pro      | 29,99  | Ja          |
| Gadget Basis    | 14,50  | Nee         |

Genereer:

-- Geëxporteerd met HTML Table Exporter PRO

CREATE TABLE products (
  productnaam TEXT,
  prijs REAL,
  op_voorraad TEXT
);

INSERT INTO products (productnaam, prijs, op_voorraad) VALUES
  ('Widget Pro', 29.99, 'Ja'),
  ('Gadget Basis', 14.50, 'Nee');

Laten we dit stap voor stap opbouwen.

Stap 1: De Tabelmatrix Extraheren

Eerst de ruwe data uit de HTML-tabel halen:

function extractTableMatrix(table) {
  const rows = Array.from(table.rows);
  const grid = [];

  rows.forEach((rowEl, rowIndex) => {
    if (!grid[rowIndex]) grid[rowIndex] = [];
    let colIndex = 0;

    Array.from(rowEl.cells).forEach(cell => {
      while (grid[rowIndex][colIndex] !== undefined) colIndex++;

      const text = cell.textContent.trim();
      const rowSpan = parseInt(cell.rowSpan) || 1;
      const colSpan = parseInt(cell.colSpan) || 1;

      for (let r = 0; r < rowSpan; r++) {
        if (!grid[rowIndex + r]) grid[rowIndex + r] = [];
        for (let c = 0; c < colSpan; c++) {
          grid[rowIndex + r][colIndex + c] = text;
        }
      }
      colIndex += colSpan;
    });
  });

  return grid;
}

Output: Een 2D-array waarin rows[0] headers zijn en rows[1+] data.

Stap 2: Kolomnamen Sanitiseren

SQL-identifiers hebben strikte regels. Headers als "Productnaam" of "Prijs (€)" moeten gesanitiseerd worden:

function sanitizeSqlIdentifier(header, fallbackIndex) {
  let id = (header || "").toString().trim();

  if (!id) {
    return `col_${fallbackIndex + 1}`;
  }

  // Normaliseer unicode (verwijder accenten)
  id = id.normalize("NFD").replace(/[\u0300-\u036f]/g, "");

  // Converteer naar lowercase snake_case
  id = id
    .toLowerCase()
    .replace(/[^a-z0-9]+/g, "_")
    .replace(/^_+|_+$/g, "");

  // Zorg dat het niet met een cijfer begint
  if (/^\d/.test(id)) {
    id = `col_${id}`;
  }

  // Fallback als leeg na sanitisatie
  if (!id) {
    return `col_${fallbackIndex + 1}`;
  }

  return id;
}

// Voorbeelden:
// "Productnaam"    → "productnaam"
// "Prijs (€)"      → "prijs"
// "2024 Omzet"     → "col_2024_omzet"
// ""               → "col_1"

Stap 3: Dubbele Kolomnamen Afhandelen

Tabellen hebben soms dubbele headers. SQL vereist unieke kolomnamen:

function makeUniqueColumnNames(headers) {
  const used = new Set();

  return headers.map((header, idx) => {
    let name = sanitizeSqlIdentifier(header, idx);
    let candidate = name;
    let counter = 1;

    while (used.has(candidate)) {
      candidate = `${name}_${counter}`;
      counter++;
    }

    used.add(candidate);
    return candidate;
  });
}

// ["Naam", "Naam", "Waarde"] → ["naam", "naam_1", "waarde"]

Stap 4: SQL-types Afleiden

Analyseer data om de juiste SQL-types te bepalen:

function inferSqlColumnTypes(rows, headerRowIndex = 0) {
  const headerRow = rows[headerRowIndex] || [];
  const dataRows = rows.slice(headerRowIndex + 1);
  const types = new Array(headerRow.length).fill("TEXT");

  for (let col = 0; col < headerRow.length; col++) {
    // Sample maximaal 50 waarden per kolom
    const values = [];
    for (let r = 0; r < Math.min(dataRows.length, 50); r++) {
      const cell = dataRows[r][col];
      const v = cell != null ? String(cell).trim() : "";
      if (v !== "") values.push(v);
    }

    if (values.length === 0) {
      types[col] = "TEXT";
      continue;
    }

    // Controleer of alle waarden overeenkomen met een type
    let allInt = true;
    let allNumeric = true;

    for (const v of values) {
      if (!/^[-+]?\d+$/.test(v)) {
        allInt = false;
      }
      if (!/^[-+]?\d+([.,]\d+)?$/.test(v)) {
        allNumeric = false;
      }
    }

    if (allInt) {
      types[col] = "INTEGER";
    } else if (allNumeric) {
      types[col] = "REAL";
    } else {
      types[col] = "TEXT";
    }
  }

  return types;
}

Typeprioriteit: INTEGER > REAL > TEXT

Als 100% van de niet-lege waarden integers zijn, gebruik INTEGER. Als ze allemaal numeriek zijn (inclusief decimalen), gebruik REAL. Anders TEXT.

Stap 5: Waarden Correct Escapen

SQL-injectie is niet alleen een beveiligingsprobleem — het beschadigt je data. Correcte escaping:

function sqlEscapeValue(raw, type) {
  // NULL-afhandeling
  if (raw == null) return "NULL";

  const v = String(raw).trim();
  if (v === "") return "NULL";

  // Numerieke types
  if (type === "INTEGER" || type === "REAL") {
    // Normaliseer decimaalscheidingsteken
    const normalized = v.replace(",", ".");
    const num = Number(normalized);

    if (!Number.isNaN(num) && Number.isFinite(num)) {
      return normalized;
    }
    // Val terug naar TEXT als het geen geldig getal is
  }

  // TEXT: escape enkele aanhalingstekens door ze te verdubbelen
  const escaped = v.replace(/'/g, "''");
  return `'${escaped}'`;
}

// Voorbeelden:
// sqlEscapeValue("Hallo", "TEXT")          → "'Hallo'"
// sqlEscapeValue("Het is goed", "TEXT")    → "'Het is goed'"
// sqlEscapeValue("29.99", "REAL")          → "29.99"
// sqlEscapeValue("", "TEXT")               → "NULL"
// sqlEscapeValue(null, "TEXT")             → "NULL"

Stap 6: De SQL Genereren

Alles samenvoegen:

function tableToSql(tableInfo) {
  const rows = tableInfo.rows || [];
  if (rows.length < 2) return "";

  const headerRowIndex = tableInfo.headerRowIndex || 0;
  const headerRow = rows[headerRowIndex];
  const dataRows = rows.slice(headerRowIndex + 1);

  if (!headerRow || headerRow.length === 0) return "";

  // Genereer kolomnamen
  const columnNames = makeUniqueColumnNames(headerRow);

  // Leid types af
  const types = inferSqlColumnTypes(rows, headerRowIndex);

  // Genereer tabelnaam
  const rawTableName = tableInfo.name || tableInfo.slug || "table";
  const tableName = sanitizeSqlIdentifier(rawTableName, 0) || "table_export";

  // CREATE TABLE statement
  const createLines = columnNames.map((col, i) => 
    `  ${col} ${types[i] || "TEXT"}`
  );
  const createStmt = `CREATE TABLE ${tableName} (\n${createLines.join(",\n")}\n);`;

  // INSERT statements
  const insertHeader = `INSERT INTO ${tableName} (${columnNames.join(", ")}) VALUES`;

  const valueLines = dataRows.map(row => {
    const values = columnNames.map((_, i) => {
      const cell = row[i];
      const type = types[i] || "TEXT";
      return sqlEscapeValue(cell, type);
    });
    return `  (${values.join(", ")})`;
  });

  // Combineer
  let sql = `-- Geëxporteerd met HTML Table Exporter\n\n${createStmt}\n\n`;

  if (valueLines.length > 0) {
    sql += `${insertHeader}\n${valueLines.join(",\n")};\n`;
  }

  return sql;
}

Volledig Voorbeeld

Invoertabel:

const tableInfo = {
  name: "Q1 Verkoopdata",
  rows: [
    ["Product", "Eenheden Verkocht", "Omzet (€)", "Winstgevend"],
    ["Widget A", "1.234", "45.678,90", "Ja"],
    ["Widget B", "567", "12.345,67", "Nee"],
    ["Gadget X", "890", "23.456,78", "Ja"]
  ]
};

Output:

-- Geëxporteerd met HTML Table Exporter

CREATE TABLE q1_verkoopdata (
  product TEXT,
  eenheden_verkocht INTEGER,
  omzet REAL,
  winstgevend TEXT
);

INSERT INTO q1_verkoopdata (product, eenheden_verkocht, omzet, winstgevend) VALUES
  ('Widget A', 1234, 45678.90, 'Ja'),
  ('Widget B', 567, 12345.67, 'Nee'),
  ('Gadget X', 890, 23456.78, 'Ja');

Let op:

Kolomnamen gesanitiseerd (Omzet (€) → omzet)
Getallen gedetecteerd en zonder aanhalingstekens
Komma's in getallen afgehandeld
Tabelnaam uit metadata

Randgevallen Afhandelen

NULL-waarden

Veel webtabellen representeren ontbrekende data anders:

const NULL_PATTERNS = ["N/A", "n/a", "-", "--", "null", "none", "."];

function sqlEscapeValue(raw, type, nullPatterns = NULL_PATTERNS) {
  if (raw == null) return "NULL";

  const v = String(raw).trim();
  if (v === "" || nullPatterns.includes(v.toLowerCase())) {
    return "NULL";
  }

  // ... rest van de functie
}

Grote Datasets

Voor tabellen met duizenden rijen, batch de INSERTs:

function tableToSqlBatched(tableInfo, batchSize = 1000) {
  // ... zelfde setup ...

  const batches = [];
  for (let i = 0; i < valueLines.length; i += batchSize) {
    const batch = valueLines.slice(i, i + batchSize);
    batches.push(`${insertHeader}\n${batch.join(",\n")};`);
  }

  return `${createStmt}\n\n${batches.join("\n\n")}`;
}

Database-specifieke Syntax

SQLite, PostgreSQL en MySQL hebben kleine syntaxverschillen:

function tableToSql(tableInfo, dialect = "sqlite") {
  // ... zelfde kolom/type-logica ...

  // Dialect-specifieke typemapping
  const typeMap = {
    sqlite: { INTEGER: "INTEGER", REAL: "REAL", TEXT: "TEXT" },
    postgresql: { INTEGER: "INTEGER", REAL: "NUMERIC", TEXT: "TEXT" },
    mysql: { INTEGER: "INT", REAL: "DECIMAL(10,2)", TEXT: "VARCHAR(255)" }
  };

  const dialectTypes = typeMap[dialect] || typeMap.sqlite;

  const createLines = columnNames.map((col, i) => 
    `  ${col} ${dialectTypes[types[i]] || dialectTypes.TEXT}`
  );

  // ... rest van de functie ...
}

Browser-bookmarklet

Snelle oplossing voor incidenteel gebruik:

javascript:(function(){
  const table = document.querySelector("table");
  if (!table) { alert("Geen tabel gevonden"); return; }

  const rows = Array.from(table.rows).map(r => 
    Array.from(r.cells).map(c => c.textContent.trim())
  );

  const headers = rows[0].map((h, i) => 
    (h || `col_${i+1}`).toLowerCase().replace(/[^a-z0-9]+/g, "_")
  );

  const values = rows.slice(1).map(row => 
    "(" + row.map(v => `'${v.replace(/'/g, "''")}'`).join(", ") + ")"
  ).join(",\n");

  const sql = `INSERT INTO table_data (${headers.join(", ")}) VALUES\n${values};`;

  navigator.clipboard.writeText(sql);
  alert("SQL gekopieerd naar klembord!");
})();

Wanneer Gebruik Je Dit

Geschikt voor:

Snelle data-imports in SQLite/PostgreSQL
Testdatabases vullen
Eenmalige datamigraties
SQL leren met voorbeelden

Niet ideaal voor:

Grootschalige ETL (gebruik daarvoor echte tools)
Complexe schema's (foreign keys, constraints)
Binaire data

Voor productie-datapipelines zijn goede ETL-tools met validatie beter. Voor "ik heb deze tabel nu in mijn database nodig" is directe SQL-generatie snel.

Probeer Het Zonder Code

Als je dit niet zelf wilt bouwen, genereert HTML Table Exporter PRO SQL met één klik. De gratis versie exporteert naar CSV/JSON/Excel; PRO voegt SQL, NDJSON en dataopschoning toe.

Bekijk de vergelijking van verschillende exportmethodes in onze gids over HTML-tabelscraper extensies voor Chrome.

Meer informatie op gauchogrid.com/nl/html-table-exporter of probeer het in de Chrome Web Store.

Naar welke database importeer jij webdata? Ik ben benieuwd naar de use cases.

Du Tableau HTML aux Instructions SQL INSERT en Un Clic

circobit — Mon, 22 Jun 2026 08:00:00 +0000

Vous avez trouvé des données sur un site web. Vous en avez besoin dans votre base de données. Le workflow habituel : exporter en CSV, importer dans un outil SQL, gérer les incompatibilités de types, corriger les problèmes d'encodage.

Et si vous pouviez passer directement du tableau HTML à du SQL valide ?

Ce guide montre comment générer des instructions CREATE TABLE et INSERT INTO à partir de n'importe quel tableau web, en gérant l'inférence de types, l'assainissement des identifiants et l'échappement correct. C'est l'approche que j'utilise dans HTML Table Exporter.

Le Résultat Final

À partir d'un tableau comme celui-ci :

| Nom du Produit  | Prix   | En Stock |
|-----------------|--------|----------|
| Widget Pro      | 29.99  | Oui      |
| Gadget Basic    | 14.50  | Non      |

Générer :

-- Exporté depuis HTML Table Exporter PRO

CREATE TABLE produits (
  nom_du_produit TEXT,
  prix REAL,
  en_stock TEXT
);

INSERT INTO produits (nom_du_produit, prix, en_stock) VALUES
  ('Widget Pro', 29.99, 'Oui'),
  ('Gadget Basic', 14.50, 'Non');

Construisons cela étape par étape.

Étape 1 : Extraire la Matrice du Tableau

D'abord, extraire les données brutes du tableau HTML :

function extractTableMatrix(table) {
  const rows = Array.from(table.rows);
  const grid = [];

  rows.forEach((rowEl, rowIndex) => {
    if (!grid[rowIndex]) grid[rowIndex] = [];
    let colIndex = 0;

    Array.from(rowEl.cells).forEach(cell => {
      while (grid[rowIndex][colIndex] !== undefined) colIndex++;

      const text = cell.textContent.trim();
      const rowSpan = parseInt(cell.rowSpan) || 1;
      const colSpan = parseInt(cell.colSpan) || 1;

      for (let r = 0; r < rowSpan; r++) {
        if (!grid[rowIndex + r]) grid[rowIndex + r] = [];
        for (let c = 0; c < colSpan; c++) {
          grid[rowIndex + r][colIndex + c] = text;
        }
      }
      colIndex += colSpan;
    });
  });

  return grid;
}

Sortie : Un tableau 2D où rows[0] est les en-têtes et rows[1+] sont les données.

Étape 2 : Assainir les Noms de Colonnes

Les identifiants SQL ont des règles strictes. Des en-têtes comme « Nom du Produit » ou « Prix (€) » nécessitent un assainissement :

function sanitizeSqlIdentifier(header, fallbackIndex) {
  let id = (header || "").toString().trim();

  if (!id) {
    return `col_${fallbackIndex + 1}`;
  }

  // Normaliser l'unicode (supprimer les accents)
  id = id.normalize("NFD").replace(/[\u0300-\u036f]/g, "");

  // Convertir en snake_case minuscules
  id = id
    .toLowerCase()
    .replace(/[^a-z0-9]+/g, "_")
    .replace(/^_+|_+$/g, "");

  // S'assurer que ça ne commence pas par un chiffre
  if (/^\d/.test(id)) {
    id = `col_${id}`;
  }

  if (!id) {
    return `col_${fallbackIndex + 1}`;
  }

  return id;
}

// Exemples :
// "Nom du Produit" → "nom_du_produit"
// "Prix (€)"       → "prix"
// "2024 Revenus"   → "col_2024_revenus"
// ""               → "col_1"

Étape 3 : Gérer les Noms de Colonnes en Double

Les tableaux ont parfois des en-têtes dupliqués. SQL exige des noms de colonnes uniques :

function makeUniqueColumnNames(headers) {
  const used = new Set();

  return headers.map((header, idx) => {
    let name = sanitizeSqlIdentifier(header, idx);
    let candidate = name;
    let counter = 1;

    while (used.has(candidate)) {
      candidate = `${name}_${counter}`;
      counter++;
    }

    used.add(candidate);
    return candidate;
  });
}

// ["Nom", "Nom", "Valeur"] → ["nom", "nom_1", "valeur"]

Étape 4 : Inférer les Types SQL

Analyser les données pour déterminer les types SQL appropriés :

function inferSqlColumnTypes(rows, headerRowIndex = 0) {
  const headerRow = rows[headerRowIndex] || [];
  const dataRows = rows.slice(headerRowIndex + 1);
  const types = new Array(headerRow.length).fill("TEXT");

  for (let col = 0; col < headerRow.length; col++) {
    const values = [];
    for (let r = 0; r < Math.min(dataRows.length, 50); r++) {
      const cell = dataRows[r][col];
      const v = cell != null ? String(cell).trim() : "";
      if (v !== "") values.push(v);
    }

    if (values.length === 0) {
      types[col] = "TEXT";
      continue;
    }

    let allInt = true;
    let allNumeric = true;

    for (const v of values) {
      if (!/^[-+]?\d+$/.test(v)) {
        allInt = false;
      }
      if (!/^[-+]?\d+([.,]\d+)?$/.test(v)) {
        allNumeric = false;
      }
    }

    if (allInt) {
      types[col] = "INTEGER";
    } else if (allNumeric) {
      types[col] = "REAL";
    } else {
      types[col] = "TEXT";
    }
  }

  return types;
}

Priorité des types : INTEGER > REAL > TEXT

Étape 5 : Échapper les Valeurs Correctement

L'injection SQL n'est pas seulement un problème de sécurité — elle corrompt vos données. Échappement correct :

function sqlEscapeValue(raw, type) {
  if (raw == null) return "NULL";

  const v = String(raw).trim();
  if (v === "") return "NULL";

  if (type === "INTEGER" || type === "REAL") {
    const normalized = v.replace(",", ".");
    const num = Number(normalized);

    if (!Number.isNaN(num) && Number.isFinite(num)) {
      return normalized;
    }
  }

  // TEXT : échapper les apostrophes en les doublant
  const escaped = v.replace(/'/g, "''");
  return `'${escaped}'`;
}

// Exemples :
// sqlEscapeValue("Bonjour", "TEXT")      → "'Bonjour'"
// sqlEscapeValue("C'est bon", "TEXT")    → "'C''est bon'"
// sqlEscapeValue("29.99", "REAL")        → "29.99"
// sqlEscapeValue("", "TEXT")             → "NULL"
// sqlEscapeValue(null, "TEXT")           → "NULL"

Étape 6 : Générer le SQL

En assemblant le tout :

function tableToSql(tableInfo) {
  const rows = tableInfo.rows || [];
  if (rows.length < 2) return "";

  const headerRowIndex = tableInfo.headerRowIndex || 0;
  const headerRow = rows[headerRowIndex];
  const dataRows = rows.slice(headerRowIndex + 1);

  if (!headerRow || headerRow.length === 0) return "";

  const columnNames = makeUniqueColumnNames(headerRow);
  const types = inferSqlColumnTypes(rows, headerRowIndex);

  const rawTableName = tableInfo.name || tableInfo.slug || "table";
  const tableName = sanitizeSqlIdentifier(rawTableName, 0) || "table_export";

  // Instruction CREATE TABLE
  const createLines = columnNames.map((col, i) => 
    `  ${col} ${types[i] || "TEXT"}`
  );
  const createStmt = `CREATE TABLE ${tableName} (\n${createLines.join(",\n")}\n);`;

  // Instructions INSERT
  const insertHeader = `INSERT INTO ${tableName} (${columnNames.join(", ")}) VALUES`;

  const valueLines = dataRows.map(row => {
    const values = columnNames.map((_, i) => {
      const cell = row[i];
      const type = types[i] || "TEXT";
      return sqlEscapeValue(cell, type);
    });
    return `  (${values.join(", ")})`;
  });

  let sql = `-- Exporté depuis HTML Table Exporter\n\n${createStmt}\n\n`;

  if (valueLines.length > 0) {
    sql += `${insertHeader}\n${valueLines.join(",\n")};\n`;
  }

  return sql;
}

Gestion des Cas Limites

Valeurs NULL

De nombreux tableaux web représentent les données manquantes différemment :

const NULL_PATTERNS = ["N/A", "n/a", "-", "--", "null", "none", "."];

function sqlEscapeValue(raw, type, nullPatterns = NULL_PATTERNS) {
  if (raw == null) return "NULL";

  const v = String(raw).trim();
  if (v === "" || nullPatterns.includes(v.toLowerCase())) {
    return "NULL";
  }

  // ... reste de la fonction
}

Grands Jeux de Données

Pour les tableaux avec des milliers de lignes, regroupez les INSERT par lots :

function tableToSqlBatched(tableInfo, batchSize = 1000) {
  // ... même configuration ...

  const batches = [];
  for (let i = 0; i < valueLines.length; i += batchSize) {
    const batch = valueLines.slice(i, i + batchSize);
    batches.push(`${insertHeader}\n${batch.join(",\n")};`);
  }

  return `${createStmt}\n\n${batches.join("\n\n")}`;
}

Syntaxe Spécifique aux Bases de Données

SQLite, PostgreSQL et MySQL ont de légères différences de syntaxe :

function tableToSql(tableInfo, dialect = "sqlite") {
  // ... même logique colonnes/types ...

  const typeMap = {
    sqlite: { INTEGER: "INTEGER", REAL: "REAL", TEXT: "TEXT" },
    postgresql: { INTEGER: "INTEGER", REAL: "NUMERIC", TEXT: "TEXT" },
    mysql: { INTEGER: "INT", REAL: "DECIMAL(10,2)", TEXT: "VARCHAR(255)" }
  };

  const dialectTypes = typeMap[dialect] || typeMap.sqlite;

  const createLines = columnNames.map((col, i) => 
    `  ${col} ${dialectTypes[types[i]] || dialectTypes.TEXT}`
  );

  // ... reste de la fonction ...
}

Quand Utiliser Ceci

Adapté pour :

Imports rapides de données dans SQLite/PostgreSQL
Peupler des bases de données de test
Migrations de données ponctuelles
Apprendre le SQL par l'exemple

Moins adapté pour :

ETL à grande échelle (utilisez des outils dédiés)
Schémas complexes (clés étrangères, contraintes)
Données binaires

Pour des pipelines de données en production, des outils ETL avec validation sont préférables. Pour « j'ai besoin de ce tableau dans ma base de données maintenant », la génération directe de SQL est rapide.

Essayez-le Sans Code

Si vous ne voulez pas construire tout cela vous-même, HTML Table Exporter PRO génère du SQL en un clic. La version gratuite exporte en CSV/JSON/Excel ; la version PRO ajoute SQL, NDJSON et le nettoyage de données.

Pour une comparaison des meilleures extensions d'export, consultez notre guide des scrapers de tableaux HTML pour Chrome.

En savoir plus sur gauchogrid.com/fr/html-table-exporter ou essayez-le sur le Chrome Web Store.

Dans quelle base de données importez-vous des données web ? Je suis curieux de connaître les cas d'utilisation.

Tabelas da Wikipédia Que Quebram a Maioria dos Scrapers (E Como Corrigir)

circobit — Thu, 18 Jun 2026 12:00:00 +0000

A Wikipédia é a fonte mais comum de dados tabulares na web. Também é um campo minado de casos extremos que quebram scrapers ingênuos.

Coletei os cinco padrões que mais causam problemas enquanto construía o HTML Table Exporter, com código de detecção e correções para cada um.

Padrão 1: Linhas de Navegação ("v t e")

O Problema:

<table>
  <tr>
    <td colspan="5">v t e Países por população</td>
  </tr>
  <tr>
    <td>Rank</td><td>País</td><td>População</td>...
  </tr>
  ...
</table>

A primeira linha contém links "v t e" (Ver/Falar/Editar) para páginas de template da Wikipédia. Se seu scraper trata a linha 0 como cabeçalhos, tudo quebra.

O que pd.read_html produz:

          v t e Países por população
0   Rank                        País    ...
1      1                       China    ...

Detecção:

def is_nav_row(row_values):
    """Detectar prefixo de navegação da Wikipédia."""
    if not row_values:
        return False

    first_cell = str(row_values[0]).strip().lower()
    patterns = [
        r'^v\s+t\s+e\s',        # "v t e "
        r'^v\s*\|\s*t\s*\|\s*e', # "v | t | e"
        r'^\[v\]\s*\[t\]\s*\[e\]' # "[v] [t] [e]"
    ]

    import re
    return any(re.match(p, first_cell) for p in patterns)

Correção:

import pandas as pd

def read_wikipedia_table(url, table_index=0):
    tables = pd.read_html(url)
    df = tables[table_index]

    # Verificar se a primeira linha é navegação
    if is_nav_row(df.iloc[0].values):
        # Usar a segunda linha como cabeçalho
        df.columns = df.iloc[1]
        df = df.iloc[2:].reset_index(drop=True)

    return df

Padrão 2: Tabelas Duplicadas Horizontalmente

O Problema:

Para economizar espaço vertical, a Wikipédia exibe algumas tabelas em múltiplas colunas:

| Rank | Nome   | Pop  | Rank | Nome    | Pop  |
|------|--------|------|------|---------|------|
| 1    | Tóquio | 37M  | 11   | Paris   | 11M  |
| 2    | Delhi  | 32M  | 12   | Cairo   | 10M  |

Isso é logicamente UMA tabela com estrutura de colunas repetida.

O que pd.read_html produz:

   Rank    Nome  Pop  Rank.1   Nome.1  Pop.1
0     1  Tóquio  37M      11    Paris    11M
1     2   Delhi  32M      12    Cairo    10M

O Pandas vê 6 colunas. Se você filtrar por "Nome", perde metade dos dados.

Detecção:

def detect_horizontal_duplication(columns):
    """Verificar se colunas se repetem (Rank, Nome, Pop, Rank, Nome, Pop)."""
    cols = list(columns)
    n = len(cols)

    # Tentar dividir por 2, 3, 4
    for divisor in [2, 3, 4]:
        if n % divisor != 0:
            continue

        chunk_size = n // divisor
        base_pattern = [c.rstrip('.0123456789') for c in cols[:chunk_size]]

        is_duplicate = True
        for i in range(1, divisor):
            chunk = cols[i * chunk_size : (i + 1) * chunk_size]
            normalized = [c.rstrip('.0123456789') for c in chunk]
            if normalized != base_pattern:
                is_duplicate = False
                break

        if is_duplicate:
            return chunk_size

    return None

Correção:

def normalize_duplicated_table(df, base_columns):
    """Empilhar tabelas duplicadas horizontalmente de forma vertical."""
    n_repeats = len(df.columns) // base_columns

    frames = []
    for i in range(n_repeats):
        start = i * base_columns
        end = start + base_columns
        chunk = df.iloc[:, start:end].copy()
        chunk.columns = df.columns[:base_columns]
        # Remover linhas onde todos os valores são NaN (segunda metade vazia)
        chunk = chunk.dropna(how='all')
        frames.append(chunk)

    return pd.concat(frames, ignore_index=True)

# Uso
df = pd.read_html(url)[0]
chunk_size = detect_horizontal_duplication(df.columns)
if chunk_size:
    df = normalize_duplicated_table(df, chunk_size)

Padrão 3: Linhas de Título (Ocupando Todas as Colunas)

O Problema:

<table>
  <tr>
    <td colspan="4">Lista dos edifícios mais altos do mundo</td>
  </tr>
  <tr>
    <td>Rank</td><td>Edifício</td><td>Cidade</td><td>Altura</td>
  </tr>
  ...
</table>

A primeira linha é um título, não dados. Após a expansão do colspan, ela se torna:

['Lista dos edifícios...', 'Lista dos edifícios...', 'Lista dos edifícios...', 'Lista dos edifícios...']

Detecção:

def is_title_row(row_values, next_row_values):
    """Detectar linhas de título de largura total."""
    if not row_values or not next_row_values:
        return False

    # Todos os valores são iguais (colspan expandido)
    unique_values = set(str(v).strip() for v in row_values if str(v).strip())

    # Linha de título: 1 valor único, próxima linha tem múltiplos valores únicos
    # E o valor é longo (> 20 caracteres tipicamente para títulos)
    if len(unique_values) == 1:
        title = list(unique_values)[0]
        next_unique = len(set(str(v).strip() for v in next_row_values if str(v).strip()))
        return len(title) > 20 and next_unique > 2

    return False

Correção:

def skip_title_rows(df):
    """Remover linhas de título do topo de um dataframe."""
    skip_count = 0

    for i in range(min(3, len(df) - 1)):
        current_row = df.iloc[i].values
        next_row = df.iloc[i + 1].values if i + 1 < len(df) else None

        if is_title_row(current_row, next_row):
            skip_count = i + 1
        else:
            break

    if skip_count > 0:
        # Usar a linha após os títulos como cabeçalho
        df.columns = df.iloc[skip_count]
        df = df.iloc[skip_count + 1:].reset_index(drop=True)

    return df

Padrão 4: Cabeçalhos Agrupados (Dois Níveis)

O Problema:

|        |         | Estatísticas      | Estatísticas     |
| Rank   | País    | PIB (nominal)     | PIB (PPP)        |
|--------|---------|-------------------|------------------|
| 1      | EUA     | 25,5 trilhões     | 25,5 trilhões    |

A linha 0 são cabeçalhos de categoria. A linha 1 são os cabeçalhos reais das colunas. Ambas são semanticamente "cabeçalhos".

O que pd.read_html produz:

Frequentemente corrompido ou com MultiIndex difícil de trabalhar.

Detecção:

def has_grouped_headers(df):
    """Detectar cabeçalhos agrupados de dois níveis."""
    if len(df) < 3:
        return False

    row0 = df.iloc[0].values
    row1 = df.iloc[1].values

    # Contar valores consecutivos repetidos na linha 0
    repeat_count = 0
    for i in range(1, len(row0)):
        if str(row0[i]).strip() == str(row0[i-1]).strip() and str(row0[i]).strip():
            repeat_count += 1

    repeat_ratio = repeat_count / max(1, len(row0) - 1)

    # Cabeçalhos agrupados tipicamente têm 40%+ de valores repetidos
    # E a linha 1 tem mais valores únicos não-vazios que a linha 0
    unique0 = len(set(str(v).strip() for v in row0 if str(v).strip()))
    unique1 = len(set(str(v).strip() for v in row1 if str(v).strip()))

    return repeat_ratio > 0.3 and unique1 > unique0

Correção:

def merge_grouped_headers(df):
    """Mesclar cabeçalhos de dois níveis em nível único."""
    group_row = df.iloc[0].values
    header_row = df.iloc[1].values

    merged = []
    for i, (group, header) in enumerate(zip(group_row, header_row)):
        g = str(group).strip()
        h = str(header).strip()

        if not g or g == h:
            merged.append(h)
        elif not h:
            merged.append(g)
        else:
            merged.append(f"{g} - {h}")

    df.columns = merged
    return df.iloc[2:].reset_index(drop=True)

# Uso
if has_grouped_headers(df):
    df = merge_grouped_headers(df)

Padrão 5: Tabelas Aninhadas em Infoboxes

O Problema:

Infoboxes da Wikipédia contêm tabelas dentro de células de tabelas:

<table class="infobox">
  <tr>
    <td>População</td>
    <td>
      <table>  <!-- Aninhada! -->
        <tr><td>Urbana</td><td>8,3M</td></tr>
        <tr><td>Metro</td><td>20,1M</td></tr>
      </table>
    </td>
  </tr>
</table>

O que pd.read_html produz:

Tanto a tabela externa quanto a interna são retornadas. Se você procura "todas as tabelas da página", obtém duplicatas e lixo aninhado.

Detecção e Filtragem:

from bs4 import BeautifulSoup
import requests

def get_top_level_tables(url):
    """Obter apenas tabelas de nível superior, não aninhadas."""
    response = requests.get(url)
    soup = BeautifulSoup(response.text, 'html.parser')

    all_tables = soup.find_all('table')

    top_level = []
    for table in all_tables:
        # Verificar se esta tabela está dentro de outra tabela
        parent = table.parent
        is_nested = False

        while parent:
            if parent.name == 'table':
                is_nested = True
                break
            parent = parent.parent

        if not is_nested:
            top_level.append(table)

    return top_level

def read_top_level_tables(url):
    """Ler apenas tabelas de nível superior como DataFrames."""
    import pandas as pd

    tables = get_top_level_tables(url)

    dfs = []
    for table in tables:
        try:
            # Converter tabela individual em DataFrame
            df = pd.read_html(str(table))[0]
            dfs.append(df)
        except Exception:
            continue

    return dfs

Leitor Completo de Tabelas da Wikipédia

Combinando todas as correções:

import pandas as pd
import requests
from bs4 import BeautifulSoup
import re

class WikipediaTableReader:
    def __init__(self, url):
        self.url = url
        self.soup = None

    def _fetch(self):
        if self.soup is None:
            response = requests.get(self.url)
            self.soup = BeautifulSoup(response.text, 'html.parser')

    def _is_nav_row(self, values):
        if not values:
            return False
        first = str(values[0]).strip().lower()
        return bool(re.match(r'^v\s+t\s+e\s', first))

    def _is_title_row(self, values, next_values):
        unique = set(str(v).strip() for v in values if str(v).strip())
        if len(unique) != 1:
            return False
        title = list(unique)[0]
        next_unique = len(set(str(v).strip() for v in next_values if str(v).strip()))
        return len(title) > 20 and next_unique > 2

    def get_tables(self, skip_infobox=True):
        """Obter todas as tabelas de dados da página."""
        self._fetch()

        tables = self.soup.find_all('table')
        results = []

        for table in tables:
            # Pular tabelas aninhadas
            if table.find_parent('table'):
                continue

            # Pular infoboxes se solicitado
            if skip_infobox and 'infobox' in table.get('class', []):
                continue

            try:
                df = pd.read_html(str(table))[0]
                df = self._clean_table(df)
                if len(df) > 0 and len(df.columns) > 1:
                    results.append(df)
            except Exception:
                continue

        return results

    def _clean_table(self, df):
        """Aplicar todas as etapas de limpeza."""
        # Pular linhas de navegação
        while len(df) > 0 and self._is_nav_row(df.iloc[0].values):
            df.columns = df.iloc[1] if len(df) > 1 else df.columns
            df = df.iloc[2:].reset_index(drop=True) if len(df) > 2 else df.iloc[1:]

        # Pular linhas de título
        if len(df) > 1:
            while self._is_title_row(df.iloc[0].values, df.iloc[1].values if len(df) > 1 else []):
                df.columns = df.iloc[1]
                df = df.iloc[2:].reset_index(drop=True)

        return df

# Uso
reader = WikipediaTableReader("https://pt.wikipedia.org/wiki/Lista_de_países_por_população")
tables = reader.get_tables()

Quando Usar uma Extensão

Se você está fazendo extração pontual (não construindo um pipeline), uma extensão de navegador lida com todos esses padrões automaticamente.

O HTML Table Exporter detecta esses padrões e normaliza a saída. Um clique vs. depurar casos extremos. Para uma comparação detalhada de ferramentas de extração de tabelas, confira nosso guia de scrapers de tabelas HTML para Chrome.

Para pipelines automatizados, use o código acima. Para exportações ocasionais, use a ferramenta certa para o trabalho.

Saiba mais em gauchogrid.com/pt-br/html-table-exporter ou experimente grátis na Chrome Web Store.

Encontrou uma tabela da Wikipédia que quebra este código? Compartilhe a URL — vou adicioná-la à minha suíte de testes.