CSV to SQL

Generera SQL INSERT-satser från CSV-data

Prova ett exempel

CSV-indata

SQL-utdata

Körs lokalt · Säkert att klistra in hemligheter
SQL visas här…
Tabellnamn:

Vad är CSV till SQL-konvertering?

CSV till SQL-konvertering omvandlar kommaseparerade värden till Structured Query Language-satser som en relationsdatabas kan köra. Det vanligaste resultatet är ett par: en CREATE TABLE-sats som definierar kolumnerna, och en eller flera INSERT INTO-satser som fyller kolumnerna med raderna från CSV-filen.

CSV-filer följer RFC 4180-specifikationen. Varje rad är en post, fält separeras av ett avgränsartecken (vanligtvis ett kommatecken) och fält som innehåller avgränsartecknet eller radbrytningar omges av dubbla citattecken. SQL är å andra sidan standardspråket för att hantera data i system som PostgreSQL, MySQL, SQLite och SQL Server. Att konvertera mellan dessa två format är en av de vanligaste dataimportuppgifterna inom mjukvaruutveckling.

En korrekt CSV-till-SQL-konverterare hanterar citering, undantar enkla citattecken i värden (fördubblar dem till '' enligt SQL-standarden), mappar kolumnrubriker till giltiga SQL-identifierare och kan valfritt härleda datatyper. Utöver grundläggande undantagshantering normaliserar en bra konverterare rubriknamn (ersätter mellanslag och bindestreck med understreck) och omsluter utdatan i ett transaktionsblock, så att ett importmisslyckande återställs rent i stället för att lämna partiella data i tabellen. Utan en konverterare är det tidskrävande och felbenäget att skriva INSERT-satser för hand, även för ett par hundra rader.

Varför använda en CSV till SQL-konverterare?

Att skriva SQL INSERT-satser för hand från kalkylbladsdata är omständligt och inbjuder till syntaxfel. En konverterare automatiserar de repetitiva delarna så att du kan fokusera på schemadesign och datavalidering.

Generera SQL på sekunder
Klistra in din CSV och få körfärdig SQL-utdata direkt. Inget behov av att manuellt citera strängar, undanta apostrofer eller räkna kolumner. Konverteringen körs helt i din webbläsare.
🔒
Håll data i webbläsaren
Din CSV lämnar aldrig din dator. All tolkning och SQL-generering sker på klientsidan, vilket innebär ingen serveruppladdning, ingen loggning och ingen tredjepartsåtkomst till din datamängd.
🎯
Producera korrekt SQL-syntax
Enkla citattecken i värden undantas som '' enligt SQL-standarden. Kolumnnamn rensas till giltiga identifierare. Utdatan är syntaktiskt giltig för PostgreSQL, MySQL och SQLite.
📋
Hantera valfri CSV-struktur
Verktyget identifierar automatiskt avgränsartecken (kommatecken, semikolon, tabb, vertikalstreck) och hanterar citerade fält med inbäddade kommatecken eller radbrytningar, enligt RFC 4180-reglerna.

Användningsområden för CSV till SQL

Databasinitierering
Konvertera en CSV-fixtursfil till INSERT-satser för utvecklings- eller stagingdatabaser. Praktiskt i CI-pipelines där du behöver upprepningsbara testdata utan ett ORM.
Datamigrering
Flytta data exporterad från ett system (CRM, kalkylblad, äldre applikation) till en ny relationsdatabas. Generera SQL:en, granska den och kör den sedan i en transaktion.
Backend-API-utveckling
Fyll snabbt en lokal PostgreSQL- eller MySQL-instans med testdata från en CSV. Snabbare än att skriva ett migreringsskript när du bara behöver en engångsinläsning.
QA och testautomatisering
Generera SQL från CSV-testfixturer för att sätta upp databastillstånd inför integrationstester. Kombinera med ett nedrivningsskript för att återställa tabellen mellan testkörningar.
Förberedelse av dataanalys
Läs in CSV-datamängder i SQLite för ad hoc-frågor. SQLite läser SQL INSERT-satser direkt, vilket ger en snabb väg från kalkylbladsexport till sökbar data.
Lära sig SQL
Studenter kan konvertera exempel-CSV:er till SQL för att öva på SELECT, JOIN och aggregatfrågor på verklighetstrogen data utan att behöva bygga ett schema från grunden.

Referens för SQL-datatyper

Vid konvertering av CSV till SQL används TEXT som standardtyp för alla kolumner eftersom CSV saknar typmetadata. Om du känner till kolumntyperna kan du ersätta TEXT i CREATE TABLE-utdatan. Den här tabellen visar de vanligaste SQL-typerna och när du bör använda respektive typ.

TypAnvänds förAnteckningar
TEXT / VARCHARStrings, mixed contentDefault safe choice; works in every SQL dialect
INTEGER / INTWhole numbers (age, count, ID)Use when column contains only digits with no decimals
REAL / FLOATDecimal numbers (price, rate)Needed for columns with dots like 19.99 or 3.14
DATEISO 8601 dates (2024-01-15)Requires consistent formatting; varies by database
BOOLEANtrue/false, 1/0, yes/noMySQL uses TINYINT(1); PostgreSQL has native BOOL
NUMERIC / DECIMALExact precision (currency)Specify scale: DECIMAL(10,2) for money columns
BLOB / BYTEABinary dataRarely needed in CSV imports; use for hex-encoded fields

Jämförelse av SQL-dialekter

SQL-syntaxen varierar mellan databasmotorer. De genererade INSERT-satserna använder standard-SQL som fungerar i de flesta system, men vissa funktioner skiljer sig åt. Den här tabellen sammanfattar de skillnader som är viktigast vid import av CSV-data.

FunktionPostgreSQLMySQLSQLiteSQL Server
Identifier quoting"col"`col`"col"[col]
String escape'''' or \'''''
INSERT syntaxINSERT INTOINSERT INTOINSERT INTOINSERT INTO
Batch INSERTVALUES (),()…VALUES (),()…VALUES (),()…max 1000 rows
Auto-incrementSERIALAUTO_INCREMENTAUTOINCREMENTIDENTITY(1,1)
Upsert / mergeON CONFLICTON DUPLICATE KEYON CONFLICTMERGE
NULL handlingIS NULLIS NULL / <=>IS NULLIS NULL
COPY from CSVCOPY … FROMLOAD DATA INFILE.importBULK INSERT

INSERT vs COPY: Att välja importmetod

För små till medelstora datamängder (under 10 000 rader) fungerar INSERT-satser bra och är portabla till alla SQL-databaser. För stora importer erbjuder databaser massinläsningskommandon som kringgår SQL-tolkaren helt.

INSERT INTO
Standard-SQL. Fungerar överallt. Varje rad tolkas som en SQL-sats, vilket ger högre overhead för stora datamängder. Stöder villkorlig logik (ON CONFLICT, ON DUPLICATE KEY). Bäst för testdata, små migreringar och fall där du behöver kontroll på radnivå.
COPY / LOAD DATA
Databasspecifik massinläsare. PostgreSQL använder COPY, MySQL använder LOAD DATA INFILE, SQLite använder .import och SQL Server använder BULK INSERT. Läser CSV direkt och kringgår SQL-tolkaren. 10–100 gånger snabbare för stora filer (100 000+ rader). Kräver filsystemsåtkomst på servern eller klienten.

Kodexempel

Dessa exempel visar hur man konverterar CSV till SQL INSERT-satser i olika programmeringsspråk. Varje exempel hanterar undantagshantering av enkla citattecken och rensning av kolumnnamn.

JavaScript (Node.js)
// CSV → SQL INSERT statements
const csv = `name,age,city
Alice,30,Berlin
Bob,25,Tokyo`

function csvToSql(csv, table = 'data') {
  const rows = csv.trim().split('\n').map(r => r.split(','))
  const [headers, ...data] = rows
  const cols = headers.map(h => h.trim().toLowerCase().replace(/\s+/g, '_'))

  const values = data.map(row =>
    '  (' + row.map(v => `'${v.replace(/'/g, "''").trim()}'`).join(', ') + ')'
  )

  return `INSERT INTO ${table} (${cols.join(', ')}) VALUES
${values.join(',\n')};`
}

console.log(csvToSql(csv, 'users'))
// → INSERT INTO users (name, age, city) VALUES
//     ('Alice', '30', 'Berlin'),
//     ('Bob', '25', 'Tokyo');
Python
import csv
import io

csv_string = """name,age,city
Alice,30,Berlin
Bob,25,Tokyo"""

reader = csv.reader(io.StringIO(csv_string))
headers = [h.strip().lower().replace(' ', '_') for h in next(reader)]

table = 'users'
rows = list(reader)

# CREATE TABLE
col_defs = ', '.join(f'{h} TEXT' for h in headers)
print(f'CREATE TABLE {table} ({col_defs});')
# → CREATE TABLE users (name TEXT, age TEXT, city TEXT);

# INSERT statements
for row in rows:
    vals = ', '.join(f"'{v.replace(chr(39), chr(39)*2)}'" for v in row)
    print(f"INSERT INTO {table} ({', '.join(headers)}) VALUES ({vals});")
# → INSERT INTO users (name, age, city) VALUES ('Alice', '30', 'Berlin');
# → INSERT INTO users (name, age, city) VALUES ('Bob', '25', 'Tokyo');
Go
package main

import (
	"encoding/csv"
	"fmt"
	"strings"
)

func csvToSQL(data, table string) string {
	r := csv.NewReader(strings.NewReader(data))
	records, _ := r.ReadAll()
	if len(records) < 2 {
		return ""
	}

	headers := records[0]
	var vals []string
	for _, row := range records[1:] {
		escaped := make([]string, len(row))
		for i, v := range row {
			escaped[i] = "'" + strings.ReplaceAll(v, "'", "''") + "'"
		}
		vals = append(vals, "  ("+strings.Join(escaped, ", ")+")")
	}

	return fmt.Sprintf("INSERT INTO %s (%s) VALUES\n%s;",
		table, strings.Join(headers, ", "), strings.Join(vals, ",\n"))
}

func main() {
	csv := "name,age,city\nAlice,30,Berlin\nBob,25,Tokyo"
	fmt.Println(csvToSQL(csv, "users"))
	// → INSERT INTO users (name, age, city) VALUES
	//     ('Alice', '30', 'Berlin'),
	//     ('Bob', '25', 'Tokyo');
}
CLI (sqlite3 / psql)
# SQLite: import CSV directly into a table
sqlite3 mydb.db <<EOF
.mode csv
.import data.csv users
SELECT * FROM users LIMIT 5;
EOF

# PostgreSQL: COPY from CSV file (server-side)
psql -c "COPY users FROM '/path/to/data.csv' WITH (FORMAT csv, HEADER true);"

# PostgreSQL: \copy from CSV (client-side, no superuser needed)
psql -c "\copy users FROM 'data.csv' WITH (FORMAT csv, HEADER true);"

# MySQL: LOAD DATA from CSV
mysql -e "LOAD DATA INFILE '/path/to/data.csv' INTO TABLE users
  FIELDS TERMINATED BY ',' ENCLOSED BY '"'
  LINES TERMINATED BY '\n' IGNORE 1 ROWS;"

Vanliga frågor

Hur hanteras enkla citattecken i CSV-värden i SQL-utdatan?
Varje enkelt citattecken (') i ett CSV-värde fördubblas till '' i SQL-utdatan. Detta är SQL-standardens undantagssekvens. Till exempel blir ett värde som "O'Brien" till 'O''Brien' i INSERT-satsen. Detta fungerar i PostgreSQL, MySQL, SQLite och SQL Server.
Kan jag konvertera CSV till SQL för en specifik databas som MySQL eller PostgreSQL?
De genererade INSERT-satserna använder standard-SQL-syntax som både MySQL och PostgreSQL accepterar. Den största skillnaden är identifierarciterning: PostgreSQL använder dubbla citattecken, MySQL använder backticks. För grundläggande INSERT-operationer fungerar utdatan i båda utan ändringar.
Vad händer om min CSV saknar rubrikrad?
Konverteraren behandlar den första raden som kolumnrubriker. Om din CSV saknar rubriker, lägg till en rubrikrad innan du konverterar, annars blir den första dataraden kolumnnamnen i CREATE TABLE-satsen. De flesta konverterare, inklusive den här, kräver en rubrikrad.
Finns det en radgräns för CSV till SQL-konvertering?
Eftersom konverteringen körs i din webbläsare beror den praktiska gränsen på enhetens minnesutrymme. Filer med tiotusentals rader konverteras utan problem. För mycket stora filer (500 000+ rader) bör du använda databasens inbyggda COPY- eller LOAD DATA-kommando i stället för INSERT-satser.
Varför använder utdatan TEXT för alla kolumner i stället för INTEGER eller DATE?
CSV är ett rent textformat utan typmetadata. Konverteraren använder TEXT som ett säkert standardval för att undvika felaktig typhärledning. Du kan ändra kolumntyperna i den genererade CREATE TABLE-satsen efter att du granskat dina data. INTEGER för numeriska kolumner och DATE för datumkolumner är vanliga justeringar.
Hur ska jag hantera CSV-filer med semikolon eller tabbar som avgränsartecken?
Det här verktyget identifierar automatiskt avgränsartecknet genom att analysera den första raden i din CSV. Det kontrollerar kommatecken, semikolon, tabbar och vertikalstreck och använder det som förekommer oftast. Europeiska CSV-filer som använder semikolon fungerar utan några konfigurationsändringar.
Är den genererade SQL:en säker mot injektion om jag kör den direkt?
Utdatan undantar enkla citattecken, vilket förhindrar oavsiktliga syntaxfel. Men om din CSV-data kommer från en opålitlig källa bör du behandla den genererade SQL:en på samma sätt som du behandlar all overifierad indata. Granska utdatan innan du kör den mot en produktionsdatabas. För programmatiska importer är parametriserade frågor alltid säkrare än strängsammansättning.