Convert JSON to MySQL INSERT Statements

MySQL has no native boolean, so the active flag becomes a TINYINT(1) column with 1/0. Identifiers are backtick-quoted; the apostrophe is doubled.

Input:
[
  {"id": 1, "name": "O'Hara", "active": true},
  {"id": 2, "name": "Lee", "active": false}
]

Output (MySQL):
CREATE TABLE IF NOT EXISTS `members` (
  `id` INTEGER,
  `name` TEXT,
  `active` TINYINT(1)
);

INSERT INTO `members` (`id`, `name`, `active`)
VALUES
  (1, 'O''Hara', 1),
  (2, 'Lee', 0);

Enabling the conflict toggle in MySQL mode does not emit ON CONFLICT — it switches the keyword to INSERT IGNORE INTO, MySQL's duplicate-key skip.

Config: ON CONFLICT DO NOTHING enabled

Output (MySQL):
INSERT IGNORE INTO `roles` (`id`, `name`)
VALUES
  (1, 'admin'),
  (2, 'editor');

-- Rows whose PK/unique key already exist are skipped
-- silently. This is NOT ON DUPLICATE KEY UPDATE; there
-- is no upsert option.

A tags array isn't expanded into rows or a JSON column — it is JSON-stringified into one TEXT value. Store it, or flatten the source first.

Input:
[{"id": 1, "tags": ["alpha", "beta"]}]

Output (MySQL):
CREATE TABLE IF NOT EXISTS `posts` (
  `id` INTEGER,
  `tags` TEXT
);

INSERT INTO `posts` (`id`, `tags`)
VALUES
  (1, '["alpha","beta"]');

-- Change `tags` to JSON type in your real schema if you
-- want JSON_EXTRACT()/-> queries to work.

Turn off Include CREATE TABLE when the table already exists with your own AUTO_INCREMENT and constraints. You get only the inserts.

Config: Include CREATE TABLE = off, dialect = MySQL

Output (MySQL):
INSERT INTO `users` (`id`, `email`)
VALUES
  (1, 'a@x.com'),
  (2, 'b@x.com');

-- No CREATE TABLE emitted, so your existing column types,
-- PRIMARY KEY, and AUTO_INCREMENT are untouched.

A price with decimals is typed REAL by inference. For currency you want DECIMAL(10,2); edit the CREATE TABLE before importing.

Input:
[{"id": 1, "price": 19.99}, {"id": 2, "price": 5.00}]

Output (MySQL):
CREATE TABLE IF NOT EXISTS `products` (
  `id` INTEGER,
  `price` REAL
);

INSERT INTO `products` (`id`, `price`)
VALUES
  (1, 19.99),
  (2, 5);

-- Note 5.00 -> 5 (JSON number). For exact money, change
-- `price` REAL to `price` DECIMAL(10,2) by hand.

In MySQL mode the ON CONFLICT DO NOTHING toggle switches the keyword to INSERT IGNORE INTO. It never emits ON CONFLICT syntax (which would error in MySQL). INSERT IGNORE skips rows that violate a unique or primary key — but only if such a constraint exists on the target table. It is not an upsert.

There is no option to generate ON DUPLICATE KEY UPDATE. The only conflict behaviour is the skip-on-duplicate INSERT IGNORE. If you need MySQL upserts, generate the inserts here and rewrite them into INSERT ... ON DUPLICATE KEY UPDATE col=VALUES(col) manually.

MySQL has no real BOOLEAN type, so the column is TINYINT(1) and values are 1/0, not TRUE/FALSE. This is the correct MySQL idiom (MySQL aliases BOOLEAN to TINYINT(1) anyway). If you switch the dialect back to PostgreSQL or SQLite you'll see BOOLEAN with TRUE/FALSE instead.

Decimals make a column REAL, a binary float that rounds. For currency, edit the generated type to DECIMAL(p,s) after generating, or store money as integer cents in the JSON so the column infers as INTEGER.

JSON numbers don't preserve trailing zeros, so 5.00 becomes the number 5 and is emitted as 5. The inferred column type still depends on whether any value in the column was a decimal. If precision/formatting matters, store the value as a string in the source JSON (it will then be a TEXT column, quoted).

Objects and arrays are JSON.stringify-ed into a TEXT value, not a MySQL JSON column or child table. To use JSON_EXTRACT/-> you must change the column type to JSON in your schema, or flatten the JSON first with json-flattener.

Only .json and spreadsheet files (.xlsx/.xls/.ods) become rows. A .csv is passed straight to JSON.parse and fails. Run it through csv-to-json first, then convert the resulting array here.

The generated CREATE TABLE lists columns and inferred types only — no ENGINE=InnoDB, no DEFAULT CHARSET, no PRIMARY KEY, no AUTO_INCREMENT. Add those in your real DDL, or generate INSERT-only (turn off Include CREATE TABLE) against a table you already defined.

Free tier caps input at 2 MB, Pro at 100 MB. Larger files are rejected before conversion. Split the array into smaller files and import them in sequence, optionally with INSERT IGNORE so re-runs are safe.