I TUOI MODELLI, VISUALIZZATI
Prisma in ERD: guida
Visualizza schema.prisma con modelli, relazioni e nomi mappati. Comprendi la sintassi e correggi i problemi segnalati.
Vedi la struttura del tuo schema Prisma
Incolla schema.prisma nell'editor per visualizzare modelli, campi scalari, chiavi, enum, indici e relazioni. La conversione viene eseguita nel browser e mantiene modelli leggibili quando la diagnostica richiede attenzione.
Questo strumento visualizza il tuo schema. Non si connette al tuo datasource, non esegue Prisma Client né applica migrazioni.
Gli esempi utilizzano la sintassi dell'origine dati di Prisma 6. In Prisma 7, mantieni il provider in schema.prisma e configura l'URL di connessione in prisma.config.ts. Erd Go accetta un'origine dati con solo provider; incolla lo schema qui, non il tuo file di configurazione o le tue credenziali.
Incolla uno schema connesso
- Apri Prisma a ERD e scegli un esempio o un documento vuoto.
- Incolla lo schema qui sotto, o il tuo schema.prisma completo. Il provider del datasource controlla la validazione specifica del connettore.
- Rivedi il diagramma e la diagnostica, quindi ispeziona modelli, campi e relazioni nell'esploratore. Usa i controlli di layout per disporre il diagramma.
datasource db {
provider = "postgresql"
url = env("DATABASE_URL")
}
model User {
id Int @id @default(autoincrement())
email String @unique
posts Post[]
}
model Post {
id Int @id @default(autoincrement())
title String
authorId Int
author User @relation(fields: [authorId], references: [id])
@@index([authorId])
}Modelli, campi e nomi mappati
| Sintassi | Significato |
|---|---|
| model User { ... } | Un modello con campi scalari e di relazione. |
| String / Int / Boolean / DateTime / Decimal / Json / Bytes | Tipi di campi scalari; il supporto del connettore si applica ancora. |
| String? / Post[] | Campo opzionale / campo elenco. |
| @id / @@id([a, b]) | Chiave primaria a campo singolo / composita. |
| @unique / @@unique([a, b]) | Vincolo unique a campo singolo / composito. |
| @default(...) / @updatedAt / @db.VarChar(255) | Valori predefiniti, aggiornamento dei metadati e tipi nativi specifici del provider. |
| @map("user_id") / @@map("users") | Nome della colonna mappata / della tabella del database. |
| enum Status { ... } / @@index([field]) | Valori Enum / indici del modello. |
| @@schema("public") | Appartenenza allo schema per un'origine dati multi-schema compatibile. |
Relazioni e regole delle chiavi
Una relazione esplicita utilizza un campo di relazione, campi di chiave esterna scalari e @relation(fields: [...], references: [...]). Includi un campo di relazione opposto sull'altro modello. Fa' riferimento a una chiave primaria o a una chiave univoca globalmente con tipi scalari e nativi compatibili.
Se uno scalare di chiave esterna è opzionale, anche il suo campo di relazione proprietario deve essere opzionale. Una relazione opzionale può avere scalari obbligatori. Un proprietario uno-a-uno richiede @unique o @@unique sui suoi campi di chiave esterna, e il campo inverso senza quegli scalari deve essere opzionale.
Usa lo stesso nome di relazione tra virgolette su entrambi i lati per distinguere collegamenti multipli tra gli stessi modelli o una relazione con se stessi. I nomi possono contenere punteggiatura. I nomi dei campi e i riferimenti alle chiavi sono sensibili al maiuscolo/minuscolo; elenca ciascun campo chiave una sola volta e includi tutti i membri della chiave composta.
I bordi relazionali impliciti molti-a-molti richiedono un campo scalare a livello di @id su ciascun modello partecipante. Identificatori composti, a livello di blocco o basati solo su univocità producono una diagnostica anziché una relazione virtuale fuorviante. Utilizzare un modello di join esplicito per campi aggiuntivi, chiavi complesse o azioni referenziali.
model Profile {
id Int @id @default(autoincrement())
userId Int @unique
user User @relation(fields: [userId], references: [id])
}
model User {
id Int @id @default(autoincrement())
profile Profile?
}Enum, chiavi composte e mappature di database
Usa @@id e @@unique per le chiavi a più colonne, @map per i nomi dei campi e @@map per i nomi delle tabelle. Per un provider multi-schema compatibile, elenca gli schemi nell'origine dati e assegna i modelli con @@schema. Il nome del modello rimane utile nell'editor mentre l'identità mappata viene conservata per l'output del database.
L'esempio PostgreSQL seguente presenta una chiave primaria composita e un'email univoca con ambito tenant. Una relazione esplicita con questa chiave deve fornire tenantId e accountId nello stesso ordine con tipi di campo compatibili.
datasource db {
provider = "postgresql"
url = env("DATABASE_URL")
schemas = ["identity"]
}
enum AccountState {
ACTIVE
DISABLED
@@schema("identity")
}
model Account {
tenantId Int @map("tenant_id")
accountId Int @map("account_id")
email String
state AccountState @default(ACTIVE)
@@id([tenantId, accountId])
@@unique([tenantId, email])
@@map("accounts")
@@schema("identity")
}Provider e diagnostica recuperabile
I provider di origine dati supportati includono PostgreSQL, MySQL, SQLite, SQL Server, MongoDB e CockroachDB. Il convertitore controlla le identità specifiche del connettore, i tipi nativi, i valori predefiniti, le regole di relazione e le collisioni di nomi mappati.
I provider relazionali utilizzano per impostazione predefinita relationMode = "foreignKeys". MongoDB utilizza relationMode = "prisma" e valida la sua mappatura _id e i requisiti ObjectId. Non dare per scontato che un esempio relazionale possa essere copiato inalterato su MongoDB.
Correggi i campi di relazione opposti mancanti, i tipi di chiavi esterne incompatibili, le destinazioni di chiavi non valide e le combinazioni di provider non supportate utilizzando la diagnostica. I campi non validi ma leggibili rimangono visibili in modo da poter riparare lo schema sul posto.
| Provider | Guida specifica per connettori |
|---|---|
| PostgreSQL / CockroachDB | Gli elenchi scalari e le dichiarazioni multi-schema sono supportati; i tipi nativi e i valori predefiniti devono corrispondere al provider selezionato. |
| MySQL | Nessuna lista scalare o opzione per schemi datasource. La convalida dell'azione referenziale segue il relationMode selezionato. |
| SQLite | Nessun attributo di tipo @db nativo di Prisma, liste scalari o opzione per schemi datasource. |
| SQL Server | Nessun blocco enum, campi Json o liste scalari. Le dichiarazioni multi-schema sono supportate. |
| MongoDB | Usa relationMode = "prisma", un mapping _id e tipi scalari/nativi ObjectId corrispondenti. I blocchi di tipo composito appartengono a questo connettore. |
Esplora, Esporta e Salva
- Cerca nell'explorer per modello, campo, nome mappato, enum o relazione. Seleziona una relazione per esaminarne i campi, i riferimenti, la cardinalità e le azioni referenziali nell'Ispettore relazioni; da lì puoi mettere a fuoco ciascuna delle due estremità.
- Usa le posizioni di diagnostica per passare alla sorgente che richiede attenzione. Regola il layout e le preferenze di visualizzazione sull'ERD.
- Esporta il diagramma come PNG, SVG basato su immagine o PDF per un documento o una presentazione.
- Accedi per salvare un file Prisma con il relativo contesto di origine e renderer. Salva le modifiche prima di condividere un link pubblico di sola lettura. Un visualizzatore con cui è stato condiviso il file non riceve l'accesso alla modifica del sorgente.
Risolvere i problemi di uno schema Prisma
| Sintomo | Cosa verificare |
|---|---|
| Una relazione presenta un avviso | Verifica il campo opposto corrispondente e il nome della relazione, i tipi scalari/nativi compatibili, la chiave referenziata univoca a livello globale e i campi/riferimenti presenti solo sul lato proprietario. |
| Una relazione uno-a-uno presenta un avviso | Rendi il gruppo di chiavi esterne di appartenenza globalmente unico e la relazione inversa opzionale. Se uno scalare di appartenenza è nullable, rendi opzionale anche la sua relazione. |
| Una chiave composta non viene mostrata come globalmente unica | Controlla la presenza di nomi di campi mancanti, ripetuti, opzionali o con maiuscole/minuscole differenti. Un predicato univoco parziale viene mostrato come PUQ anziché UQ globale. |
| Manca un bordo implicito molti-a-molti | Ogni modello richiede un campo scalare a livello di @id. Usa un modello di join esplicito per identificatori composti o attributi di relazione. |
| Il diagramma viene visualizzato con errori | I campi leggibili vengono mantenuti deliberatamente. Ripara la diagnostica prima di considerare lo schema valido per il suo provider di database. |
| Il layout salvato non riflette le nuove modifiche | Salva il sorgente corrente e il contesto del renderer prima di condividere o ricaricare; i visualizzatori pubblici vedono la versione salvata. |
| La modifica del sorgente è disabilitata | Verifica la proprietà del documento, l'accesso e se il caricamento nel cloud è terminato. Gli errori di caricamento recuperabili offrono Riprova e Apri file. |
Genera Prisma con il provider corretto
Copia questa guida come prompt per l'IA, nomina la tua versione e il tuo provider di Prisma, quindi indica i tuoi modelli e le regole di business. Chiedi all'assistente di preservare i nomi esistenti @map e @@map modificando lo schema.
Incolla il Prisma restituito nell'editor e rivedi la diagnostica prima di usarlo altrove. Un diagramma visualizzato non sostituisce la validazione del provider o una revisione della migrazione.
Generate a PostgreSQL Prisma schema for User, Project, and Membership.
Use an explicit Membership join model with a composite key.
Include both sides of every relation and compatible foreign-key types.
Preserve these database table names: users, projects, memberships.