Convert JSON to PostgreSQL INSERT Statements

A categories array with a name containing an apostrophe and an active flag. Note the doubled single quote and the BOOLEAN column with TRUE/FALSE — both Postgres-correct.

Input:
[
  {"id": 1, "name": "O'Brien & Co", "active": true},
  {"id": 2, "name": "Acme", "active": false}
]

Output (PostgreSQL):
CREATE TABLE IF NOT EXISTS "categories" (
  "id" INTEGER,
  "name" TEXT,
  "active" BOOLEAN
);

INSERT INTO "categories" ("id", "name", "active")
VALUES
  (1, 'O''Brien & Co', TRUE),
  (2, 'Acme', FALSE);

A settings object is not expanded into columns — it is JSON-stringified into one TEXT field. Store it as-is and parse with Postgres JSON functions later, or normalise upstream first.

Input:
[{"id": 1, "settings": {"theme": "dark", "beta": true}}]

Output (PostgreSQL):
CREATE TABLE IF NOT EXISTS "prefs" (
  "id" INTEGER,
  "settings" TEXT
);

INSERT INTO "prefs" ("id", "settings")
VALUES
  (1, '{"theme":"dark","beta":true}');

-- To query later, cast: settings::jsonb ->> 'theme'
-- (change the column type to JSONB in your real schema)

Re-running a seed against a table that already has rows aborts on a duplicate primary key. Enabling the conflict toggle appends a table-wide skip so the script is safe to run twice.

Config: ON CONFLICT DO NOTHING enabled

Output (PostgreSQL):
INSERT INTO "roles" ("id", "name")
VALUES
  (1, 'admin'),
  (2, 'editor') ON CONFLICT DO NOTHING;

-- Note: no conflict target like (id). It is a table-wide
-- DO NOTHING, not an upsert. For real upserts you must
-- edit in ON CONFLICT (id) DO UPDATE SET ... by hand.

API exports often carry internal keys you don't want in the seed. List them in Exclude columns and they vanish from both the schema and the rows.

Input:
[{"id": 1, "email": "a@x.com", "_meta": "trace-123", "__v": 0}]

Config: Exclude columns = _meta, __v

Output (PostgreSQL):
CREATE TABLE IF NOT EXISTS "users" (
  "id" INTEGER,
  "email" TEXT
);

INSERT INTO "users" ("id", "email")
VALUES
  (1, 'a@x.com');

When rows have different keys, the column set is the union of all keys across rows. Any row missing a key gets NULL for it — no error.

Input:
[
  {"id": 1, "name": "A", "tier": "pro"},
  {"id": 2, "name": "B"}
]

Output (PostgreSQL):
CREATE TABLE IF NOT EXISTS "accounts" (
  "id" INTEGER,
  "name" TEXT,
  "tier" TEXT
);

INSERT INTO "accounts" ("id", "name", "tier")
VALUES
  (1, 'A', 'pro'),
  (2, 'B', NULL);

The conflict toggle emits ON CONFLICT DO NOTHING with no (column) target — a valid table-wide skip in Postgres, but it requires the table to have a way to detect conflicts (a primary key or unique constraint). It is not an upsert. If you need ON CONFLICT (id) DO UPDATE SET ..., edit the generated SQL by hand; the tool does not produce upserts or specify targets.

Any non-integer number makes the whole column DOUBLE PRECISION. For money you almost certainly want NUMERIC(10,2) to avoid float rounding. The tool cannot know your intent, so edit the CREATE TABLE type after generating, or pre-store currency as integer cents in the JSON.

Objects and arrays are JSON.stringify-ed into a TEXT column, not JSONB or a child table. The value round-trips as a JSON string. To query it, change the column type to JSONB in your real schema, or flatten the JSON first with json-flattener so each nested key becomes its own column.

The input must parse as a JSON array of objects, or a single object. A bare string, number, or a JSON array of primitives ([1,2,3]) will not produce a meaningful table — [1,2,3] is treated as three rows with no keys, yielding an empty column set. Wrap scalars in objects ([{"value":1}]) first.

An empty array [] produces the comment -- Empty array, no statements generated and zero statements rather than an error. Check the rows count in the stats line; if it reads 0, your extraction step probably returned nothing.

If a key holds 1 in one row and 1.5 in another, the column is typed DOUBLE PRECISION because not every value is an integer. This is correct, but it means a column you expected to be INTEGER may widen the moment a single decimal appears in the data.

Raw .csv text is passed straight to JSON.parse and fails — only .json and spreadsheet files (.xlsx/.xls/.ods, read as their first sheet) become rows. Convert CSV to a JSON array first with csv-to-json, then run it here.

Keys like order, user, or select are double-quoted in PostgreSQL output, so reserved words are safe. The same applies to the table name. This is one reason to keep the PostgreSQL dialect selected for Postgres targets rather than copying MySQL-style backtick output.

Free tier caps input at 2 MB; Pro raises it to 100 MB. A larger seed file is rejected before conversion. Split the JSON array into chunks, or use the conflict-safe re-seed pattern to load it in passes.