Local CSV to SQL / Apache Parquet Converter

Multi-Dialect SQL Generation

SQL is marketed as portable. In production migrations, every major engine uses incompatible syntax, quoting conventions, and type systems. A MySQL dump fails verbatim on PostgreSQL. Our generator handles five dialects with correctness at every layer of DDL and DML generation.

MySQL / MariaDB

Backtick identifiers allow reserved keywords as column names. BOOLEAN maps to TINYINT(1). AUTO_INCREMENT for primary keys. The generated file prepends SET NAMES utf8mb4; SET foreign_key_checks = 0; SET unique_checks = 0; for maximum import performance.

PostgreSQL

Double-quote identifiers. True native BOOLEAN type. DATETIME maps to TIMESTAMP. FLOAT to DOUBLE PRECISION. Auto-increment uses SERIAL. PostgreSQL lowercases unquoted identifiers so our generator always wraps column names in double quotes.

SQLite

Relaxed type affinity. No native BOOLEAN type (INTEGER 0/1). Auto-increment is implicit via INTEGER PRIMARY KEY and SQLite ROWID mechanism. No explicit AUTO_INCREMENT keyword needed.

SQL Server (T-SQL)

Square bracket identifier quoting. VARCHAR becomes NVARCHAR(255), TEXT becomes NVARCHAR(MAX). BOOLEAN becomes BIT. Auto-increment uses IDENTITY(1,1). File includes SET QUOTED_IDENTIFIER ON; and GO batch terminators after every DDL and INSERT chunk.

Oracle (PL/SQL)

VARCHAR becomes VARCHAR2(255). INT becomes NUMBER(10). TEXT becomes CLOB. Auto-increment uses GENERATED ALWAYS AS IDENTITY (Oracle 12c+). Identifier names truncated to 30 characters for pre-12.2 Oracle compatibility.

Schema Auto-Inference Engine

Manually typing a CREATE TABLE schema for a 200-column CSV export can take a senior DBA two hours. Our engine does it in milliseconds using cascading RegEx analysis across a 200-row statistical sample.

Type Detection Cascade (most to least specific):

1. BOOLEAN: /^(true|false|1|0|yes|no|t|f|y|n)$/i across all non-null values.
2. INT / BIGINT: /^-?\d+$/. Values exceeding 2,147,483,647 auto-upgrade to BIGINT.
3. DECIMAL / FLOAT: /^-?\d+\.\d+$/. DECIMAL(10,2) preferred for monetary values, FLOAT for scientific data.
4. DATE: Tests ISO-8601 (YYYY-MM-DD), American (MM/DD/YYYY), European (DD.MM.YYYY) patterns.
5. DATETIME: Date-plus-time patterns including ISO-8601 with T separator.
6. TEXT vs VARCHAR: If any sampled value exceeds 255 characters, maps to TEXT; otherwise VARCHAR(255).

Confidence Scoring: Displayed as a colored bar per column in the Schema tab. Calculated as (consistent_cells / sample_size) * 100. Green = 90%+ (confident), amber = 75-89% (review), red = below 75% (manual override strongly advised).

Null Handling and Data Quality Scoring

Most CSV converters silently choose a null handling strategy for you. We give you three explicit, production-tested options because the choice has significant downstream implications.

SQL NULL (Recommended)

ANSI SQL NULL represents unknown value. In three-valued logic, NULL = NULL is UNKNOWN not TRUE — so NULL values are automatically excluded from COUNT(), AVG(), and SUM() aggregates. JOINs with NULL keys behave predictably. Use this for virtually all production migrations.

Empty String

For legacy applications where NOT NULL string constraints exist or where ORMs treat NULL and empty string differently in business logic, this replaces all empty cells with ''.

Skip Rows with Any Null

For ML training data or financial reconciliation tables requiring complete records, this omits any row where at least one included column is empty. The workspace header shows the row count delta.

Data Quality Score

Calculated as (non-null cells / total cells) * 100. Green = 95%+, amber = 75-94%, red = below 75%. Sub-70% indicates the dataset needs preprocessing before loading into schemas with NOT NULL constraints.

Optimizing Bulk INSERT Performance

Every INSERT forces the engine to: parse SQL text into an AST, generate a query plan, acquire a lock, write the data page, write a WAL/redo log entry, fsync() the log to disk, release the lock, and acknowledge the client. The fsync() alone takes 0.1-0.5ms on a fast SSD. At 1 row per INSERT, 100,000 rows = up to 50 seconds of pure fsync latency before counting parsing and locking overhead.

Extended INSERT Syntax: Our generator produces batched statements: INSERT INTO t (col1, col2) VALUES (v1, v2), (v3, v4), ..., (v999, v1000); — 500 rows per statement by default. This amortizes the parse, plan, lock, and fsync cost across 500 rows simultaneously. Benchmarks show 30x-80x speedup versus single-row inserts on InnoDB tables.

MySQL Optimization Headers: The generated file automatically includes SET foreign_key_checks = 0; and SET unique_checks = 0; at the top, restored at the end. For maximum speed, temporarily set innodb_flush_log_at_trx_commit = 2 in your MySQL config before the import.

Step-by-Step Conversion Guide

1. Prepare your CSV: Save as UTF-8 from Excel (File > Save As > CSV UTF-8). Ensure the first row is a clean header row.
2. Drop the file: Drag from File Explorer onto the workspace drop zone or click to open a file picker. The delimiter is auto-detected. A data preview table renders with type badges on every column header.
3. Configure Settings: Enter the target table name, select the SQL dialect, choose null handling strategy, and set batch chunk size.
4. Review Schema tab: Switch to the Schema tab in the sidebar. Amber confidence bars deserve manual review. Override type dropdowns as needed. Uncheck columns to exclude them from the SQL output.
5. Enable DDL options: Toggle Add Auto-Increment Primary Key or DROP TABLE IF EXISTS as needed for your migration scenario.
6. Export: Click Export SQL for a .sql dump, Export JSON for a flat JSON array, or Export TSV for a tab-separated file compatible with LOAD DATA utilities.
7. Import: MySQL: mysql -u root -p db_name < output.sql. PostgreSQL: psql -U postgres -d db_name -f output.sql. SQLite: sqlite3 database.db < output.sql.

Real-World Use Cases

E-Commerce Platform Migration (Shopify to WooCommerce): Shopify exports products, customers, and orders as CSV. Re-importing into WooCommerce's MySQL tables requires correctly typed INSERT statements. Our tool converts a 50,000-product catalog to MySQL SQL in seconds, eliminating hours of manual schema writing.

Healthcare Data Processing (HIPAA Compliant): Hospital EMR systems export patient cohort data as CSV for research. Even anonymized datasets containing ICD-10 diagnosis codes and lab values cannot be uploaded to third-party servers under HIPAA. Our zero-upload architecture allows clinical analysts to convert this locally into PostgreSQL or SQLite for R or Python pipelines.

Government Open Data: Data.gov, UK data.gov.uk, and EU Open Data Portal publish hundreds of thousands of datasets exclusively as CSV. Our tool converts a 500,000-row census dataset to typed SQLite-compatible SQL in under 10 seconds.

Financial Transaction History: Bank statement and accounting system exports contain dates, currency amounts with locale-specific formatting, account numbers, and reference strings. Our DECIMAL detection correctly identifies monetary amounts. Account numbers stay VARCHAR to preserve leading zeros.

CRM Contact Migration: HubSpot, Salesforce, and Pipedrive export contacts with 80+ columns. Schema inference correctly identifies email fields (VARCHAR), phone numbers (VARCHAR — phones start with + or contain parentheses and dashes), and timestamps across timezone-aware and naive datetime formats.

Data Engineering Pipeline Integration

dbt (data build tool): Load the SQL dump into a staging schema in Snowflake, BigQuery, or Redshift. Define dbt source models pointing to that schema. The type-correct schema eliminates the most common cause of dbt run failures: implicit type cast errors where VARCHAR columns are compared to INTEGER types.

Airbyte / Fivetran: Use the SQL dump for historical backfills when setting up a new connector. Load the one-time snapshot via our SQL export while ongoing incremental sync runs via the native connector.

Python Pandas / Polars: The JSON export (flat array of objects) loads directly with pd.read_json('export.json'). Use the Schema tab detected types to provide dtype arguments to Pandas, preventing integer IDs from being coerced to floats due to NaN handling.

DuckDB (Local Analytics): Generate a CREATE TABLE from our Schema tab output, then INSERT INTO t SELECT * FROM read_csv('data.csv', header=true) for correctly typed columns from the first query.

AWS Glue / S3 Data Lake: Upload the generated SQL to S3, trigger a Lambda via S3 event notification that executes it against Aurora Serverless. This pattern powers daily data lake refresh pipelines where vendors export CSV and you maintain a queryable structured copy in RDS or Redshift Spectrum.

Why Other CSV to SQL Tools Fall Short

We analyzed the top competing web tools to identify specific gaps this converter fills. Every limitation listed below is a documented real-world failure mode in production data engineering workflows.

The zero-upload architecture is the non-negotiable differentiator. csvtosql.net, sqlizer.io, and convertcsv.com all require data transmission to third-party infrastructure. For any dataset containing personal, financial, or health information, this is a compliance failure that no feature advantage can compensate for.

CSV Encoding Issues and Real Solutions

Encoding errors are the most underestimated source of silent data corruption in CSV-to-database migrations. They do not always produce an import error — they produce wrong data that looks plausible until a downstream consumer notices garbled characters months later.

The Three Encoding Landmines

Windows-1252 (CP-1252): Excel on Windows saves "CSV (Comma delimited)" in Windows-1252 by default through Office 2021. When these bytes are interpreted as UTF-8 in a MySQL database configured for utf8mb4, European characters corrupt silently. A price field containing the Euro sign becomes multi-byte garbage with no error thrown.

UTF-8 with BOM (EF BB BF): When Excel saves as "CSV UTF-8 (Comma delimited)" it prepends a 3-byte Byte Order Mark. This invisible prefix gets captured as part of the first column header. A column named id becomes a different string with a zero-width no-break space prefix, causing SQL column references to silently fail. PapaParse strips the BOM automatically — your column headers will always be clean.

GB2312 / Shift-JIS / EUC-KR: Chinese, Japanese, and Korean locale ERP exports often arrive in these legacy encodings. Modern MySQL with CHARACTER SET utf8mb4 rejects non-UTF-8 byte sequences with "Incorrect string value" errors. Pre-convert with: iconv -f GB2312 -t UTF-8 input.csv > output.csv on Linux, or open("input.csv", encoding="gb2312") in Python with UTF-8 output.

MySQL Charset Recommendations

Always use CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci. The legacy utf8 charset in MySQL is a 3-byte subset that cannot store emoji or rare Unicode code points. Our generated SQL prepends SET NAMES utf8mb4; to match the connection charset. The detected encoding is shown in the workspace metadata row after file upload.

SQL Injection Safety in CSV-to-SQL Conversion

SQL injection is not only a web application risk — it is a data integrity hazard during bulk CSV imports. When cell values contain SQL metacharacters and are naively interpolated into INSERT statements, the generated SQL becomes syntactically broken or actively malicious.

What Can Go Wrong in a CSV Cell

Consider a name field containing an apostrophe (common in Irish and French names). Naively inserted into an unescaped SQL string literal, the apostrophe terminates the string early, producing a syntax error that aborts the entire import. Our escapeVal() function doubles all single quotes per the ANSI SQL standard — the apostrophe becomes two single quotes inside the literal, which the database parser correctly decodes back to one apostrophe.

A more dangerous case: a CSV field containing a classic SQL injection payload ('); DROP TABLE customers; --). Without escaping, the generated INSERT statement closes the string, executes the DROP, and comments out the remainder. With proper escaping, the payload becomes a harmlessly quoted string value stored verbatim in the database — inert data, not executable SQL.

Our Escaping Implementation

The escapeVal() function implements the ANSI SQL standard: all internal single quotes are doubled. We deliberately avoid backslash escaping because PostgreSQL, SQL Server, and Oracle do not recognize it as an escape sequence. Numeric type safety: For INT, BIGINT, FLOAT, DECIMAL, and BOOLEAN columns, values are emitted without quotes only when they pass a strict numeric pattern test. A cell containing injection SQL in a numeric column fails the pattern test and falls back to quoted string escaping automatically.

Post-Import Validation

• Run SELECT COUNT(*) FROM table_name; immediately after import and verify against the CSV row count shown in the workspace header.
• For financial data: verify SELECT SUM(amount_column) matches a known total from the source system.
• Check max string lengths: SELECT MAX(LENGTH(name_col)) FROM table_name; — if it equals your VARCHAR limit, rows may have been silently truncated.

Performance Benchmarks: CSV Import Methods Compared

Choosing the right import method for your dataset size separates a 3-minute job from a 3-hour job. These benchmarks were collected on Intel Core i7 / 16GB RAM / NVMe SSD against MySQL 8.0 defaults (innodb_flush_log_at_trx_commit = 1).

Tuning for Maximum Import Speed

• Set innodb_flush_log_at_trx_commit = 2 — flushes log every second instead of every commit. Reduces import time 50-70% at the cost of up to 1 second of data loss on OS crash (acceptable for batch imports on dev servers).
• Set innodb_buffer_pool_size to 70% of available RAM — keeps B-tree page splits in memory.
• Increase chunk size to 1000-2000 for narrow rows (integers and short strings).
• Reduce chunk size to 100-200 for wide TEXT/BLOB rows to stay under max_allowed_packet.
• Wrap the import in one transaction (START TRANSACTION; at top, COMMIT; at end) to batch the entire operation in a single InnoDB transaction context.

PostgreSQL COPY vs INSERT

For PostgreSQL, the COPY command bypasses the query planner and writes directly to the storage engine, achieving ~200MB/s throughput — the equivalent of MySQL LOAD DATA INFILE. However, it requires the file to be on the PostgreSQL server filesystem. Our batched INSERT method is the most universally compatible approach, working on every hosted environment: AWS RDS, Supabase, PlanetScale, Neon, and Railway.

Frequently Asked Questions

Explore More Tools

Discover more privacy-first, client-side data engineering and developer utilities in our tool collection.