JSON to SQL

The JSON to SQL Converter transforms JSON arrays into CREATE TABLE and INSERT INTO statements for your database. Paste an array of JSON objects, pick your database dialect (MySQL, PostgreSQL, SQL Server, SQLite, Oracle, MariaDB), and get ready-to-run SQL. The tool infers column types from the first few records (VARCHAR for strings, INT for integers, DECIMAL for floats, BOOLEAN for true/false, TIMESTAMP for dates), properly escapes string values (preventing SQL injection in literal data), and handles NULL values correctly. Supports nested objects (flattened with dot notation or stored as JSON columns for Postgres JSONB/MySQL JSON).

Converting JSON to SQL is a common task: importing API data into a database, migrating from NoSQL to relational, loading JSON dumps into analytics databases, or bulk-seeding test data. Doing this by hand for hundreds of rows is tedious and error-prone (missing quotes, SQL injection in string values). This tool automates the whole process — proper escaping, correct types, batched INSERTs for performance. All processing runs in your browser, so your JSON (which may contain customer data, financial records, or proprietary info) never uploads.

SQL generation from JSON:

Input format:

Array of objects (each object becomes a row):

``json
[
{"id": 1, "name": "Alice", "age": 30},
{"id": 2, "name": "Bob", "age": 25}
]
``

Output CREATE TABLE:

``sql
CREATE TABLE users (
id INT,
name VARCHAR(255),
age INT
);
``

Output INSERT:

``sql
INSERT INTO users (id, name, age) VALUES
(1, 'Alice', 30),
(2, 'Bob', 25);
``

Type inference:

Tool analyzes values across all records to determine column types:

| JSON value | MySQL | PostgreSQL | SQL Server |
|---|---|---|---|
| Integer | INT | INTEGER | INT |
| Large integer | BIGINT | BIGINT | BIGINT |
| Float | DECIMAL(10,2) | NUMERIC | DECIMAL |
| String | VARCHAR(255) | VARCHAR(255) | NVARCHAR(255) |
| Long string | TEXT | TEXT | NTEXT |
| Boolean | BOOLEAN or TINYINT | BOOLEAN | BIT |
| Date string | DATE | DATE | DATE |
| Datetime | DATETIME | TIMESTAMP | DATETIME |
| null | NULLable type | NULLable type | NULLable type |
| Nested object | JSON | JSONB | NVARCHAR(MAX) |

String escaping:

Single quotes doubled: O'Brien → O''Brien. Not backslash escaping (varies by dialect).

NULL handling:

JSON null → SQL NULL (not string 'null').
Missing field → NULL.

Batched INSERTs:

Multi-row INSERT performs better than individual statements:

```sql
-- GOOD (single round trip)
INSERT INTO users VALUES (1, 'Alice'), (2, 'Bob'), (3, 'Carol');

-- SLOWER (multiple round trips)
INSERT INTO users VALUES (1, 'Alice');
INSERT INTO users VALUES (2, 'Bob');
INSERT INTO users VALUES (3, 'Carol');
```

Tool defaults to batched. Split into smaller batches if INSERT gets too long (MySQL max_allowed_packet, PostgreSQL 1GB limit).

Dialect differences:

MySQL/MariaDB:
- VARCHAR(255) for strings.
- Backticks for identifiers: CREATE TABLE \users\`.
- INT UNSIGNED` for non-negative.

PostgreSQL:
- VARCHAR or TEXT (no length required).
- Double quotes for identifiers: "users".
- SERIAL for auto-increment columns.
- JSONB for nested objects (indexable, fast).

SQL Server:
- NVARCHAR(255) for Unicode strings.
- Brackets for identifiers: [users].
- BIT for boolean.

SQLite:
- Dynamic typing — declared types are hints.
- INTEGER for auto-increment rowid.

Oracle:
- VARCHAR2 instead of VARCHAR.
- Different datetime types.

Nested object handling:

Three strategies for nested JSON:

1. Flatten with dot notation: {user: {name: "Alice"}} → column user_name.
2. Store as JSON: PostgreSQL JSONB, MySQL JSON, SQL Server NVARCHAR(MAX) with JSON functions.
3. Split into related tables: nested array becomes child table with foreign key (relational normalization).

Tool offers all three; #2 is most common for modern databases.

Common issues:

- Column name with SQL keyword: order, group, select are keywords. Quote them with dialect-specific escape.
- Value too long for VARCHAR(255): tool checks and promotes to TEXT if needed.
- Integer overflow: INT max is 2^31-1. Use BIGINT for larger.
- Date formats: JSON dates are strings. SQL TIMESTAMP/DATE expected format varies by dialect.

JSON to SQL vs JSON to CSV: CSV is flat (no types). SQL has types and can express NULL vs empty string. For databases, SQL is better — preserves types, handles constraints.

This tool vs CSV to SQL: CSV to SQL is simpler (CSV is already flat). JSON has nested structures requiring flattening or JSON column handling.

JSON to INSERT vs JSON import commands: Postgres COPY FROM, MySQL LOAD DATA INFILE, SQL Server BULK INSERT — faster than INSERT for huge data but require specific file formats. For smaller data, INSERT is simpler.

JSON to SQL vs ORM migrations: ORM migrations (Rails migrations, Django models, Prisma schema) are for schema management. This tool for data insertion. Use ORM for ongoing structure; this tool for one-time data loads.

Relational vs JSONB storage: Relational (flattened columns) supports fast querying and indexes. JSONB (Postgres) stores JSON as-is with query operators. Trade-off: relational is optimized, JSONB is flexible.

SQL dialects comparison: MySQL/MariaDB use backticks. PostgreSQL uses double quotes. SQL Server uses brackets. Oracle uses double quotes. SQLite is mostly MySQL-compatible. Each has quirks in types and syntax.