SQL to Prisma

Convertisseur SQL DDL vers Prisma Schema (Modèles, Relations & Enums) Guide Développeur

Transformez vos instructions SQL CREATE TABLE DDL en schémas Prisma ORM propres avec modèles, relations, attributs de champ et enums.

Presets:
Fournisseur de base de données:
Entrée SQL DDL(5 tables)
datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}

generator client {
  provider = "prisma-client-js"
}

enum OrderStatus {
  PENDING
  PROCESSING
  PAID
  SHIPPED
  DELIVERED
  CANCELLED
}

enum UserRole {
  ADMIN
  CUSTOMER
  MERCHANT
}

model User {
  id           String        @id @default(uuid()) @db.Uuid
  email        String        @unique @db.VarChar(255)
  fullName     String?       @map("full_name") @db.VarChar(150)
  role         UserRole      @default("CUSTOMER")
  isVerified   Boolean       @default(false) @map("is_verified")
  metadata     Json?
  createdAt    DateTime      @default(now()) @map("created_at") @db.Timestamptz
  updatedAt    DateTime      @default(now()) @updatedAt @map("updated_at") @db.Timestamptz
  userProfile  UserProfile?
  orders       Order[]

  @@map("users")
}

model UserProfile {
  id               String   @id @default(uuid()) @db.Uuid
  userId           String   @unique @map("user_id") @db.Uuid
  avatarUrl        String?  @map("avatar_url") @db.VarChar(500)
  phoneNumber      String?  @map("phone_number") @db.VarChar(32)
  shippingAddress  String?  @map("shipping_address") @db.Text
  taxIdentifier    String?  @map("tax_identifier") @db.VarChar(64)
  user             User     @relation(fields: [userId], references: [id], onDelete: Cascade)

  @@map("user_profiles")
}

model Product {
  id              Int          @id @default(autoincrement())
  sku             String       @unique @db.VarChar(64)
  title           String       @db.VarChar(200)
  description     String?      @db.Text
  unitPrice       Decimal      @default(0.00) @map("unit_price") @db.Decimal(12, 2)
  inventoryCount  Int          @default(0) @map("inventory_count")
  isActive        Boolean      @default(true) @map("is_active")
  createdAt       DateTime     @default(now()) @map("created_at") @db.Timestamptz
  orderItems      OrderItem[]

  @@index([sku])
  @@map("products")
}

model Order {
  id             String       @id @default(uuid()) @db.Uuid
  customerId     String       @map("customer_id") @db.Uuid
  orderNumber    String       @unique @map("order_number") @db.VarChar(64)
  status         OrderStatus  @default("PENDING")
  totalAmount    Decimal      @default(0.00) @map("total_amount") @db.Decimal(12, 2)
  taxAmount      Decimal      @default(0.00) @map("tax_amount") @db.Decimal(10, 2)
  shippingNotes  String?      @map("shipping_notes") @db.Text
  createdAt      DateTime     @default(now()) @map("created_at") @db.Timestamptz
  updatedAt      DateTime     @default(now()) @updatedAt @map("updated_at") @db.Timestamptz
  customer       User         @relation(fields: [customerId], references: [id], onDelete: Restrict)
  orderItems     OrderItem[]

  @@index([status])
  @@map("orders")
}

model OrderItem {
  id         Int      @id @default(autoincrement())
  orderId    String   @map("order_id") @db.Uuid
  productId  Int      @map("product_id")
  quantity   Int      @default(1)
  unitPrice  Decimal  @map("unit_price") @db.Decimal(12, 2)
  subtotal   Decimal  @db.Decimal(12, 2)
  order      Order    @relation(fields: [orderId], references: [id], onDelete: Cascade)
  product    Product  @relation(fields: [productId], references: [id], onDelete: Restrict)

  @@unique([orderId, productId])
  @@map("order_items")
}
Modèles analysés5 models generated
Relations déduites4 foreign keys resolved
Énumérations détectées2 typed enums

Confidentialité 100% côté client

Aucun envoi serveur ni connexion réseau. L'analyse du SQL DDL et la génération du schéma Prisma s'effectuent entièrement dans votre navigateur.

Résolution intelligente des relations et clés

Détecte automatiquement les clés étrangères en créant des directives @relation typées, des références inverses bidirectionnelles et des contraintes @@id / @@unique.

Moteur DDL multi-dialectes

Prend en charge PostgreSQL, MySQL, SQLite et SQL Server : SERIAL, valeurs UUID par défaut, types natifs, index composites et enums personnalisés.

Référence technique et guide d'architecture

Convertisseur SQL DDL vers Prisma Schema (Modèles, Relations & Enums) Guide Développeur — Guide de référence

Transformez vos instructions SQL CREATE TABLE DDL en schémas Prisma ORM propres avec modèles, relations, attributs de champ et enums.

Paramètres clés et contrôles

Dialecte SQL (SQL Dialect)Enum (PostgreSQL | MySQL | SQLite | SQL Server | CockroachDB)

Dialecte SQL cible utilisé pour analyser les définitions de tables, les types de données spécifiques (comme SERIAL, VARCHAR, DATETIME2, JSONB) et les clauses de contraintes DEFAULT.

Par défaut : PostgreSQL
Convention de Nommage (Naming & Case Convention)Enum (camelCase et PascalCase avec @map | Conserver les identifiants SQL originaux)

Convertit automatiquement les noms de tables et colonnes en snake_case vers les formats idiomatiques Prisma (PascalCase pour les modèles et camelCase pour les champs) tout en insérant @@map et @map pour préserver la structure SQL existante.

Par défaut : camelCase & PascalCase with @map
Mode de Génération des Relations (Relation Mode)Enum (Relations bidirectionnelles @relation | Clés étrangères scalaires uniquement)

Définit si les contraintes de clés étrangères génèrent des relations d'objets bidirectionnelles Prisma avec tableaux fields et references explicites, ou conservent uniquement les champs scalaires de clé étrangère.

Par défaut : Relations bidirectionnelles @relation
Stratégie pour les Enums (Enum Strategy)Enum (Enum Prisma de premier niveau | Scalaire String avec commentaire)

Détermine si les types ENUM personnalisés PostgreSQL et les déclarations ENUM de colonne MySQL sont extraits en blocs enum Prisma distincts ou convertis en types scalaires String ordinaires.

Par défaut : Enum Prisma de premier niveau

Conseils de pro et bonnes practices

Préserver la compatibilité de base de données existante avec @@map et @map

Activer le mapping camelCase et PascalCase permet à votre client Prisma TypeScript d'adopter les conventions JavaScript tout en laissant la base SQL intacte grâce à @@map('nom_table') et @map('nom_colonne').

Désambiguïser les clés étrangères multiples ciblant la même table avec des noms de relation

Lorsqu'une table comporte plusieurs clés étrangères pointant vers la même cible (par exemple author_id et reviewer_id vers users), spécifiez des noms de relations explicites tels que @relation('PostAuthor', fields: [authorId], references: [id]) pour éviter l'erreur de validation P1012.

Mapper les clés primaires composites et index sur @@id et @@unique

Vérifiez que les clés primaires composites telles que PRIMARY KEY (user_id, organization_id) sont traduites en @@id([userId, organizationId]) et que les index multicolonnes deviennent @@index([fieldA, fieldB]).

Pièges courants et dépannage

Erreur de validation Prisma Schema P1012 : 'Le champ de relation ne peut pas être analysé ou le champ opposé correspondant est manquant'

Dans Prisma, les relations d'objets exigent un champ réciproque dans les deux modèles associés. Assurez-vous d'inclure toutes les instructions CREATE TABLE dépendantes dans le code DDL fourni afin que le convertisseur génère les relations bidirectionnelles complètes.

Types de colonnes non pris en charge ou spécifiques à un dialecte (ex. GEOMETRY, TSVECTOR)

Prisma propose la directive Unsupported('nom_type') pour les types de bases de données sans équivalent direct dans les scalaires Prisma. Marquez ces champs comme Unsupported ou mappez-les vers Bytes ou String selon vos besoins applicatifs.

Foire aux questions (FAQ)

Comment les clés étrangères SQL sont-elles converties en relations Prisma ?▼

Lorsqu'une clause FOREIGN KEY (author_id) REFERENCES users(id) est rencontrée, le convertisseur génère à la fois le champ scalaire (authorId Int @map('author_id')) et le champ de relation (author User @relation(fields: [authorId], references: [id])), puis insère le champ inverse (posts Post[]) dans le modèle User.

Quelle est la différence entre ce convertisseur et la commande officielle `prisma db pull` ?▼

`prisma db pull` requiert une connexion réseau directe et des identifiants valides vers une instance de base de données active. Ce convertisseur fonctionne à 100 % dans votre navigateur à partir de fichiers DDL de migration, sans nécessiter d'accès serveur ou de droits d'administration.

Comment les clés primaires composites et les index composites sont-ils représentés ?▼

Les clés primaires composites PRIMARY KEY (col1, col2) deviennent des attributs @@id([col1, col2]), les contraintes d'unicité composites deviennent @@unique([col1, col2]) et les index secondaires deviennent @@index([col1, col2]).

Le convertisseur prend-il en charge les valeurs SQL DEFAULT et les séquences auto-incrémentées ?▼

Oui. Les clauses AUTO_INCREMENT (MySQL) et SERIAL / IDENTITY (PostgreSQL/SQL Server) sont converties en @default(autoincrement()), DEFAULT CURRENT_TIMESTAMP devient @default(now()) et les valeurs littérales par défaut sont mappées vers les attributs @default(...).

Outils et utilitaires connexes

Tous les outils →
Convertisseur Docker Run en Docker Compose (CLI vers YAML) Guide Développeurdeveloper

Convertissez les commandes docker run, montages de volumes, mappages de ports et variables d'environnement en services docker-compose.yml propres et prêts pour la production.

Ouvrir l'outil→
Guide Développeur : Générateur de Configuration Nginx Upstream & Équilibrage de Chargedeveloper

Générez des blocs upstream Nginx prêts pour la production avec round-robin, least_conn, ip_hash, connexions persistantes keepalive et vérifications d'état passives.

Ouvrir l'outil→
Convertisseur Cron vers Kubernetes CronJob YAML et Générateur de Spécificationdeveloper

Convertissez des expressions crontab classiques en manifestes Kubernetes CronJob prêts pour la production avec restartPolicy, concurrencyPolicy, quotas de ressources et gestion des fuseaux horaires.

Ouvrir l'outil→
Générateur de Schémas GraphQL SDL depuis JSON (Types, Queries & Inputs) - Guide Développeurdeveloper

Générez des définitions de types d'objets, de types d'entrée (inputs) et de schémas de requêtes en syntaxe GraphQL SDL à partir d'objets JSON.

Ouvrir l'outil→
Générateur de Règles d'Alerte et d'Enregistrement Prometheus (PromQL) - Guide Développeurdeveloper

Créez et validez visuellement des règles d'alerte et d'enregistrement PromQL, des seuils, des étiquettes et des annotations de runbook.

Ouvrir l'outil→
Guide Développeur : Générateur de Types de Résolveurs TypeScript depuis GraphQL SDLdeveloper

Générez des interfaces de résolveurs TypeScript strictement typées, des arguments de requêtes/mutations et des types de contexte depuis vos schémas GraphQL SDL.

Ouvrir l'outil→