Which SQL dialects are supported?

The converter supports standard SQL DDL from PostgreSQL, MySQL, MariaDB, and SQLite. It handles CREATE TABLE statements with common data types including VARCHAR, TEXT, INT, BIGINT, BOOLEAN, TIMESTAMP, DATETIME, JSON, JSONB, SERIAL, and more.

How does it handle nullable fields?

Columns without the NOT NULL constraint are converted to optional Prisma fields using the ? modifier (e.g. String?). Columns marked NOT NULL or PRIMARY KEY become required fields in the Prisma schema.

Is my SQL sent to a server?

No. All parsing and Prisma schema generation happens 100% client-side in your browser using a custom regex/tokenization parser. Your SQL statements and database schemas never leave your device.

Does it handle DEFAULT values and auto-increment?

Yes. DEFAULT CURRENT_TIMESTAMP maps to @default(now()), DEFAULT false maps to @default(false), AUTO_INCREMENT and SERIAL types map to @default(autoincrement()), and string/number defaults are preserved with @default(...).

SQL → Prisma Schema

Paste your SQL CREATE TABLE statements and instantly generate clean Prisma schema models. Perfect for migrating existing databases to Prisma ORM.

SQL Input

1.0KB

CREATE TABLE users (
  id SERIAL PRIMARY KEY,
  email VARCHAR(255) NOT NULL,
  name VARCHAR(100),
  bio TEXT,
  age INT,
  is_active BOOLEAN NOT NULL DEFAULT true,
  role VARCHAR(20) NOT NULL DEFAULT 'user',
  avatar_url TEXT,
  login_count INT NOT NULL DEFAULT 0,
  last_login TIMESTAMP,
  created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
  updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE posts (
  id BIGINT PRIMARY KEY AUTO_INCREMENT,
  title VARCHAR(255) NOT NULL,
  slug VARCHAR(255) NOT NULL UNIQUE,
  content TEXT,
  published BOOLEAN NOT NULL DEFAULT false,
  view_count INT NOT NULL DEFAULT 0,
  author_id INT NOT NULL,
  category_id INT,
  created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
  updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE categories (
  id INT PRIMARY KEY AUTO_INCREMENT,
  name VARCHAR(100) NOT NULL UNIQUE,
  description TEXT,
  parent_id INT,
  sort_order INT NOT NULL DEFAULT 0,
  created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
);

Prisma Schema Output

model User {
  id  Int  @id  @default(autoincrement())
  email  String
  name  String?
  bio  String?
  age  Int?
  isActive  Boolean  @default(true)  @map("is_active")
  role  String  @default("user")
  avatarUrl  String?  @map("avatar_url")
  loginCount  Int  @default(0)  @map("login_count")
  lastLogin  DateTime?  @map("last_login")
  createdAt  DateTime  @default(now())  @map("created_at")
  updatedAt  DateTime  @default(now())  @map("updated_at")

  @@map("users")
}

model Post {
  id  BigInt  @id  @default(autoincrement())
  title  String
  slug  String  @unique
  content  String?
  published  Boolean  @default(false)
  viewCount  Int  @default(0)  @map("view_count")
  authorId  Int  @map("author_id")
  categoryId  Int?  @map("category_id")
  createdAt  DateTime  @default(now())  @map("created_at")
  updatedAt  DateTime  @default(now())  @map("updated_at")

  @@map("posts")
}

model Category {
  id  Int  @id  @default(autoincrement())
  name  String  @unique
  description  String?
  parentId  Int?  @map("parent_id")
  sortOrder  Int  @default(0)  @map("sort_order")
  createdAt  DateTime  @default(now())  @map("created_at")

  @@map("categories")
}

Why Convert SQL to Prisma Schema?

Migrate Existing Databases to Prisma

If you have existing SQL tables and want to adopt Prisma ORM, manually rewriting every table definition as a Prisma model is tedious and error-prone. This converter automates the process, mapping SQL types to Prisma types, handling nullable fields, defaults, primary keys, and unique constraints automatically.

Type-Safe Database Access

Prisma generates a fully type-safe client from your schema. By converting SQL DDL to Prisma models, you instantly get autocomplete, compile-time checks, and runtime validation for every database query — eliminating common bugs caused by schema mismatches between SQL and application code.

Common Use Cases

Migrate legacy MySQL databases to Prisma ORM
Convert PostgreSQL schemas for new TypeScript projects
Bootstrap Prisma schema from existing SQL dumps
Generate type-safe models from database documentation
Convert SQLite schemas for edge/serverless deployments
Create Prisma models from database migration files
Port Django/Rails SQL to Node.js with Prisma
Convert stored procedure table definitions to models
Generate Prisma schema from database reverse-engineering

How It Works

This tool parses your SQL entirely in the browser and converts each CREATE TABLE statement into a Prisma model:

VARCHAR / TEXT → String
INT / INTEGER → Int
BIGINT / BIGSERIAL → BigInt
BOOLEAN → Boolean
TIMESTAMP / DATETIME → DateTime
JSON / JSONB → Json
PRIMARY KEY → @id
AUTO_INCREMENT / SERIAL → @default(autoincrement())
DEFAULT CURRENT_TIMESTAMP → @default(now())
NOT NULL omitted → Type? (optional)

All processing happens locally in your browser — no SQL is uploaded to any server, ensuring your database schemas remain completely private.

Explore More Developer Tools

Boost your productivity with our other privacy-first utilities.

View all Developer tools →

New

AI Mock Generator

Generate realistic mock data from natural language prompts. Runs entirely in your browser — no API keys required, no data leaves your machine.

Live

JWT Debugger

Decode, inspect, and validate JWT token headers and payloads without sending credentials to any server. Fully offline, privacy-first debugging.

New

Aurora Gradient Generator

Create animated, pure CSS aurora backgrounds and mesh gradients. Generate Tailwind classes or raw CSS instantly. 100% local, privacy-first execution.