# Self-relations (/docs/orm/prisma-schema/data-model/relations/self-relations)

Location: ORM > Prisma Schema > Data Model > Relations > Self-relations

A relation field can reference its own model, called a *self-relation*. Self-relations can be 1-1, 1-n, or m-n.

> [!INFO]
> Self-relations always require the `@relation` attribute.

One-to-one self-relations [#one-to-one-self-relations]

```prisma
model User {
  id          Int     @id @default(autoincrement())
  name        String?
  successorId Int?    @unique
  successor   User?   @relation("BlogOwnerHistory", fields: [successorId], references: [id])
  predecessor User?   @relation("BlogOwnerHistory")
}
```

This expresses:

* A user can have zero or one predecessor
* A user can have zero or one successor

**Key rules:**

* Both sides must use the same `@relation` name
* One side must be fully annotated with `fields` and `references`
* The foreign key needs `@unique` for 1-1
* Cannot be required on both sides (impossible to create first record)

One-to-many self relations [#one-to-many-self-relations]

```prisma
model User {
  id        Int     @id @default(autoincrement())
  name      String?
  teacherId Int?
  teacher   User?   @relation("TeacherStudents", fields: [teacherId], references: [id])
  students  User[]  @relation("TeacherStudents")
}
```

This expresses:

* A user has zero or one teacher
* A user can have zero or more students

No `@unique` constraint on `teacherId` - multiple students can share the same teacher.

Many-to-many self relations [#many-to-many-self-relations]

```prisma
model User {
  id         Int     @id @default(autoincrement())
  name       String?
  followedBy User[]  @relation("UserFollows")
  following  User[]  @relation("UserFollows")
}
```

This expresses:

* A user can be followed by zero or more users
* A user can follow zero or more users

For relational databases, this is an implicit m-n (Prisma manages the relation table).

**Explicit version** (for storing additional fields):

```prisma
model User {
  id         Int       @id @default(autoincrement())
  name       String?
  followedBy Follows[] @relation("followedBy")
  following  Follows[] @relation("following")
}

model Follows {
  followedBy   User @relation("followedBy", fields: [followedById], references: [id])
  followedById Int
  following    User @relation("following", fields: [followingId], references: [id])
  followingId  Int
  @@id([followingId, followedById])
}
```

Multiple self-relations on same model [#multiple-self-relations-on-same-model]

You can combine multiple self-relations:

```prisma
model User {
  id         Int     @id @default(autoincrement())
  name       String?
  teacherId  Int?
  teacher    User?   @relation("TeacherStudents", fields: [teacherId], references: [id])
  students   User[]  @relation("TeacherStudents")
  followedBy User[]  @relation("UserFollows")
  following  User[]  @relation("UserFollows")
}
```

## Related pages

- [`Many-to-many relations`](https://www.prisma.io/docs/orm/prisma-schema/data-model/relations/many-to-many-relations): How to define and work with many-to-many relations in Prisma.
- [`One-to-many relations`](https://www.prisma.io/docs/orm/prisma-schema/data-model/relations/one-to-many-relations): How to define and work with one-to-many relations in Prisma.
- [`One-to-one relations`](https://www.prisma.io/docs/orm/prisma-schema/data-model/relations/one-to-one-relations): How to define and work with one-to-one relations in Prisma.
- [`Referential actions`](https://www.prisma.io/docs/orm/prisma-schema/data-model/relations/referential-actions): Referential actions let you define the update and delete behavior of related models on the database level
- [`Relation mode`](https://www.prisma.io/docs/orm/prisma-schema/data-model/relations/relation-mode): Manage relations between records with relation modes in Prisma