TypeScript Academy · Lektion

Relationer og joins med typer

Modellér relationer, så joinede resultater får korrekte typer

Lektion 4 af 413 trin

Relationer og joins med typer er en gratis TypeScript Academy-lektion på CoddyKit. Dette er lektion 4 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i TypeScript Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. TypeScript Academy-kurset indeholder 4 lektioner i alt.

Typede relationer og indlejrede resultater

Virkelige skemaer har relationer: en bruger har mange opslag, og et opslag tilhører en bruger. En typesikker ORM lader dig erklære disse relationer og returnerer derefter korrekt indlejrede resultater med typer fra relationelle forespørgsler.

Erklæring af relationer

Ud over tabeller definerer du et relationsobjekt, der beskriver, hvordan de hænger sammen. Disse metadata driver både SQL-genereringen og resultattypen.

import { relations } from "drizzle-orm";

export const usersRelations = relations(users, ({ many }) => ({
  posts: many(posts),
}));

export const postsRelations = relations(posts, ({ one }) => ({
  author: one(users, {
    fields: [posts.authorId],
    references: [users.id],
  }),
}));

En relationel forespørgsel

Forespørgsels-API'et lader dig anmode om relaterede rækker med with. Resultatet indlejrer de relaterede data under relationens navn.

const result = await db.query.users.findMany({
  with: { posts: true },
});
// result: (User & { posts: Post[] })[]

one og many former typen

En many-relation giver et array, mens en one-relation giver et enkelt objekt (eller null). Den indlejrede type matcher den kardinalitet, du erklærede.

const r = await db.query.posts.findMany({
  with: { author: true },
});
// r: (Post & { author: User })[]   // author is a single object

Valg af kolonner i relationer

Du kan indsnævre både den overordnede række og de indlejrede rækker. Resultattypen indsnævres uafhængigt på hvert niveau.

const r = await db.query.users.findMany({
  columns: { id: true, name: true },
  with: {
    posts: { columns: { title: true } },
  },
});
// r: { id: number; name: string; posts: { title: string }[] }[]

Manuelle JOINs med typede kolonner

JOINs på lavere niveau forbliver også typede. JOIN-prædikatet bruger typede kolonnereferencer, og select bestemmer den flade resultatform.

const rows = await db
  .select({ author: users.name, title: posts.title })
  .from(posts)
  .innerJoin(users, eq(users.id, posts.authorId));
// rows: { author: string; title: string }[]

left join introducerer nullabilitet

Et LEFT JOIN kan give manglende rækker på højre side, så de sammenføjede kolonner bliver nullable i resultattypen. ORM'en afspejler automatisk dette.

const rows = await db
  .select({ name: users.name, title: posts.title })
  .from(users)
  .leftJoin(posts, eq(posts.authorId, users.id));
// rows: { name: string; title: string | null }[]

Indlejrede kontra flade resultater

Relationelle forespørgsler (findMany + with) giver indlejrede objekter, mens manuelle JOINs giver flade rækker. Vælg indlejrede resultater, når du vil have objektgrafer, og flade resultater, når du vil have tabelformede projektioner.

Sådan er indlejring typet

Relationsmetadata læses på typeniveau. Forespørgselstypen kombinerer basisrækken med et objekt, hvis nøgler er de ønskede relationer, og hver nøgle afbildes til en arraytype eller enkel type efter relationens kardinalitet.

type WithPosts = User & { posts: Post[] };
// "many" -> Post[], "one" -> User (or User | null for optional)

Dybt indlejrede relationer

Relationer kan sammensættes. Du kan anmode om en relation til en relation, og typen indlejres tilsvarende dybt, helt automatisk infereret.

await db.query.users.findMany({
  with: { posts: { with: { comments: true } } },
});
// User & { posts: (Post & { comments: Comment[] })[] }

Hvorfor det er vigtigt

Manuelt typede resultater fra indlejrede JOINs er fejlbehæftede og kommer let ud af trit med skemaet. Når de afledes fra erklærede relationer, forbliver objektgrafens type og SQL'en synkroniserede, så en omdøbning af en relation giver en kompileringsfejl i stedet for en overraskelse i produktionen.

Hurtigt tjek

Test din forståelse af typede relationer og JOINs.

Besvar den i den interaktive lektion

Opsummering

Du erklærede relationer og lod derefter ORM'en producere indlejrede resultater med typer: many giver arrays, one giver enkeltobjekter, delvise selects indsnævrer hvert niveau, LEFT JOINs introducerer nullabilitet, og dybt indlejrede relationer kan sammensættes. Relationsmetadata driver både SQL og resultattyper og holder dem synkroniserede.

Gratis at komme i gang

Lær TypeScript med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 101
Lektioner: 352

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Relationer og joins med typer” gratis?

Ja — hele teksten til “Relationer og joins med typer” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af TypeScript Academy-kurset, skal du opgradere til CoddyKit PRO. TypeScript Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Relationer og joins med typer”?

Modellér relationer, så joinede resultater får korrekte typer Du øver dig i TypeScript Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på TypeScript Academy?

Der kræves ingen tidligere erfaring. TypeScript Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 4 af 4.

Hvor lang tid tager lektionen “Relationer og joins med typer”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne TypeScript Academy-lektion?

Ja. Alle TypeScript Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til TypeScript Academy