,
]}>
@@ -111,7 +101,7 @@ model User {
-> **Note**: The Prisma schema has powerful data modeling features. For example, it allows you to define "Prisma-level" [relation fields](/concepts/components/prisma-schema/relations) which will make it easier to work with [relations in the Prisma Client API](/concepts/components/prisma-client/relation-queries). In the case above, the `posts` field on `User` is defined only on "Prisma-level", meaning it does not manifest as a foreign key in the underlying database.
+> **Note**: The Prisma schema has powerful data modeling features. For example, it allows you to define "Prisma-level" [relation fields](/orm/prisma-schema/data-model/relations) which will make it easier to work with [relations in the Prisma Client API](/orm/prisma-client/queries/relation-queries). In the case above, the `posts` field on `User` is defined only on "Prisma-level", meaning it does not manifest as a foreign key in the underlying database.
In this schema, you configure three things:
@@ -121,11 +111,11 @@ In this schema, you configure three things:
### The Prisma data model
-On this page, the focus is on the data model. You can learn more about [Data sources](/concepts/components/prisma-schema/data-sources) and [Generators](/concepts/components/prisma-schema/generators) on the respective docs pages.
+On this page, the focus is on the data model. You can learn more about [Data sources](/orm/prisma-schema/overview/data-sources) and [Generators](/orm/prisma-schema/overview/generators) on the respective docs pages.
#### Functions of Prisma models
-The data model is a collection of [models](/concepts/components/prisma-schema/data-model#defining-models). A model has two major functions:
+The data model is a collection of [models](/orm/prisma-schema/data-model/models#defining-models). A model has two major functions:
- Represent a table in relational databases or a collection in MongoDB
- Provide the foundation for the queries in the Prisma Client API
@@ -134,10 +124,10 @@ The data model is a collection of [models](/concepts/components/prisma-schema/da
There are two major workflows for "getting" a data model into your Prisma schema:
-- Manually writing the data model and mapping it to the database with [Prisma Migrate](/concepts/components/prisma-migrate)
-- Generating the data model by [introspecting](/concepts/components/introspection) a database
+- Manually writing the data model and mapping it to the database with [Prisma Migrate](/orm/prisma-migrate)
+- Generating the data model by [introspecting](/orm/prisma-schema/introspection) a database
-Once the data model is defined, you can [generate Prisma Client](/concepts/components/prisma-client/working-with-prismaclient/generating-prisma-client) which will expose CRUD and more queries for the defined models. If you're using TypeScript, you'll get full type-safety for all queries (even when only retrieving the subsets of a model's fields).
+Once the data model is defined, you can [generate Prisma Client](/orm/prisma-client/setup-and-configuration/generating-prisma-client) which will expose CRUD and more queries for the defined models. If you're using TypeScript, you'll get full type-safety for all queries (even when only retrieving the subsets of a model's fields).
### Accessing your database with Prisma Client
@@ -149,7 +139,7 @@ The first step when using Prisma Client is installing the `@prisma/client` npm p
npm install @prisma/client
```
-Installing the `@prisma/client` package invokes the `prisma generate` command, which reads your Prisma schema and _generates_ Prisma Client code. The code is [generated into the `node_modules/.prisma/client` folder by default](/concepts/components/prisma-client/working-with-prismaclient/generating-prisma-client#the-prismaclient-npm-package).
+Installing the `@prisma/client` package invokes the `prisma generate` command, which reads your Prisma schema and _generates_ Prisma Client code. The code is [generated into the `node_modules/.prisma/client` folder by default](/orm/prisma-client/setup-and-configuration/generating-prisma-client#the-prismaclient-npm-package).
After you change your data model, you'll need to manually re-generate Prisma Client to ensure the code inside `node_modules/.prisma/client` gets updated:
@@ -186,7 +176,7 @@ const prisma = new PrismaClient()
Now you can start sending queries via the generated Prisma Client API, here are a few sample queries. Note that all Prisma Client queries return _plain old JavaScript objects_.
-Learn more about the available operations in the [Prisma Client API reference](/concepts/components/prisma-client).
+Learn more about the available operations in the [Prisma Client API reference](/orm/prisma-client).
##### Retrieve all `User` records from the database
@@ -245,7 +235,7 @@ const post = await prisma.post.update({
#### Usage with TypeScript
-Note that when using TypeScript, the result of this query will be _statically typed_ so that you can't accidentally access a property that doesn't exist (and any typos are caught at compile-time). Learn more about leveraging Prisma Client's generated types on the [Advanced usage of generated types](/concepts/components/prisma-client/advanced-type-safety/operating-against-partial-structures-of-model-types) page in the docs.
+Note that when using TypeScript, the result of this query will be _statically typed_ so that you can't accidentally access a property that doesn't exist (and any typos are caught at compile-time). Learn more about leveraging Prisma Client's generated types on the [Advanced usage of generated types](/orm/prisma-client/type-safety/operating-against-partial-structures-of-model-types) page in the docs.
## Typical Prisma workflows
@@ -255,7 +245,7 @@ As mentioned above, there are two ways for "getting" your data model into the Pr
With **Prisma Migrate**, Prisma's integrated database migration tool, the workflow looks as follows:
-1. Manually adjust your [Prisma data model](/concepts/components/prisma-schema/data-model)
+1. Manually adjust your [Prisma data model](/orm/prisma-schema/data-model/models)
1. Migrate your development database using the `prisma migrate dev` CLI command
1. Use Prisma Client in your application code to access your database
@@ -263,9 +253,9 @@ With **Prisma Migrate**, Prisma's integrated database migration tool, the workfl
To learn more about the Prisma Migrate workflow, see:
-- [Deploying database changes with Prisma Migrate](/guides/deployment/deploy-database-changes-with-prisma-migrate)
+- [Deploying database changes with Prisma Migrate](/orm/prisma-client/deployment/deploy-database-changes-with-prisma-migrate)
-* [Developing with Prisma Migrate](/guides/migrate/developing-with-prisma-migrate)
+* [Developing with Prisma Migrate](/orm/prisma-migrate)
### SQL migrations and introspection
@@ -274,10 +264,10 @@ The typical workflow when using **SQL migrations and introspection** is slightly
1. Manually adjust your database schema using SQL or a third-party migration tool
1. (Re-)introspect your database
-1. Optionally [(re-)configure your Prisma Client API](/concepts/components/prisma-client/working-with-prismaclient/use-custom-model-and-field-names))
+1. Optionally [(re-)configure your Prisma Client API](/orm/prisma-client/setup-and-configuration/custom-model-and-field-names))
1. (Re-)generate Prisma Client
1. Use Prisma Client in your application code to access your database
-To learn more about the introspection workflow, please refer the [introspection section](/concepts/components/introspection).
+To learn more about the introspection workflow, please refer the [introspection section](/orm/prisma-schema/introspection).
diff --git a/content/200-concepts/050-overview/200-why-prisma.mdx b/content/200-orm/050-overview/100-introduction/200-why-prisma.mdx
similarity index 100%
rename from content/200-concepts/050-overview/200-why-prisma.mdx
rename to content/200-orm/050-overview/100-introduction/200-why-prisma.mdx
diff --git a/content/200-concepts/050-overview/250-should-you-use-prisma.mdx b/content/200-orm/050-overview/100-introduction/250-should-you-use-prisma.mdx
similarity index 80%
rename from content/200-concepts/050-overview/250-should-you-use-prisma.mdx
rename to content/200-orm/050-overview/100-introduction/250-should-you-use-prisma.mdx
index 1cb4caa5c9..060c5fbb2e 100644
--- a/content/200-concepts/050-overview/250-should-you-use-prisma.mdx
+++ b/content/200-orm/050-overview/100-introduction/250-should-you-use-prisma.mdx
@@ -47,7 +47,7 @@ Here's an overview of the different scenarios where Prisma might or might not be
This is the main use case for Prisma. Server-side applications typically are API servers that expose data operations via technologies like REST, GraphQL or gRPC. They are commonly built as microservices or monolithic apps and deployed via long-running servers or serverless functions. Prisma is a great fit for all of these application and deployment models.
-Refer to the full list of databases (relational, NoSQL, and NewSQL) that Prisma [supports](/reference/database-reference/supported-databases).
+Refer to the full list of databases (relational, NoSQL, and NewSQL) that Prisma [supports](/orm/reference/supported-databases).
### ... you care about productivity and developer experience
@@ -67,26 +67,26 @@ Here are a couple of the guiding principles and general practices we apply when
Prisma shines especially when used in collaborative environments.
-The declarative [Prisma schema](/concepts/components/prisma-schema) provides an overview of the current state of the database that's easy to understand for everyone. This is a major improvement to traditional workflows where developers have to dig through migration files to understand the current table structure.
+The declarative [Prisma schema](/orm/prisma-schema) provides an overview of the current state of the database that's easy to understand for everyone. This is a major improvement to traditional workflows where developers have to dig through migration files to understand the current table structure.
-[Prisma Client](/concepts/components/prisma-client)'s minimal API surface enables developers to pick it up quickly without much learning overhead, so onboarding new developers to a team becomes a lot smoother.
+[Prisma Client](/orm/prisma-client)'s minimal API surface enables developers to pick it up quickly without much learning overhead, so onboarding new developers to a team becomes a lot smoother.
-The [Prisma Migrate](/concepts/components/prisma-migrate) workflows are designed in a way to cover database schema changes in collaborative environments. From the initial schema creation up to the point of deploying schema changes to production and resolving conflicts that were introduced by parallel modifications, Prisma Migrate has you covered.
+The [Prisma Migrate](/orm/prisma-migrate) workflows are designed in a way to cover database schema changes in collaborative environments. From the initial schema creation up to the point of deploying schema changes to production and resolving conflicts that were introduced by parallel modifications, Prisma Migrate has you covered.
### ... you want a tool that holistically covers your database workflows
Prisma is a lot more than "just another ORM". We are building a database toolkit that covers the daily workflows of application developers that interact with databases. A few examples are:
-- querying (with [Prisma Client](/concepts/components/prisma-client))
-- data modeling (in the [Prisma schema](/concepts/components/prisma-schema))
-- migrations (with [Prisma Migrate](/concepts/components/prisma-migrate))
-- prototyping (via [`prisma db push`](/reference/api-reference/command-reference#db-push))
-- seeding (via [`prisma db seed`](/reference/api-reference/command-reference#db-seed))
+- querying (with [Prisma Client](/orm/prisma-client))
+- data modeling (in the [Prisma schema](/orm/prisma-schema))
+- migrations (with [Prisma Migrate](/orm/prisma-migrate))
+- prototyping (via [`prisma db push`](/orm/reference/prisma-cli-reference#db-push))
+- seeding (via [`prisma db seed`](/orm/reference/prisma-cli-reference#db-seed))
- visual viewing and editing (with [Prisma Studio](https://www.prisma.io/studio))
### ... you value type-safety
-Prisma is the only _fully_ type-safe ORM in the TypeScript ecosystem. The generated Prisma Client ensures typed query results even for partial queries and relations. You can learn more about this in the [type-safety comparison with TypeORM](/concepts/more/comparisons/prisma-and-typeorm#type-safety).
+Prisma is the only _fully_ type-safe ORM in the TypeScript ecosystem. The generated Prisma Client ensures typed query results even for partial queries and relations. You can learn more about this in the [type-safety comparison with TypeORM](/orm/more/comparisons/prisma-and-typeorm#type-safety).
### ... you want an ORM with a transparent development process, proper maintenance & support
@@ -106,7 +106,7 @@ Prisma has a lively [community](https://www.prisma.io/community), which you can
### ... you need _full_ control over all database queries
-Prisma is an abstraction. As such, an inherent tradeoff of Prisma is a reduced amount of control in exchange for higher productivity. This means, the [Prisma Client API](/concepts/components/prisma-client) might have less capabilities in some scenarios than you get with plain SQL.
+Prisma is an abstraction. As such, an inherent tradeoff of Prisma is a reduced amount of control in exchange for higher productivity. This means, the [Prisma Client API](/orm/prisma-client) might have less capabilities in some scenarios than you get with plain SQL.
If your application has requirements for database queries that Prisma does not provide and the workarounds are too costly, you might be better off with a tool that allows you to exercise full control over your database operations using plain SQL.
@@ -134,7 +134,7 @@ _Alternatives_: [Hasura](https://hasura.io/), [Postgraphile](https://www.graphil
### ... you want to use raw, type-safe SQL for querying your database
-While Prisma does allow you to [send plain SQL queries](/concepts/components/prisma-client/raw-database-access) to your database, it might not be the best fit if you prefer to work with a SQL-based abstraction that you want to be type-safe. Prisma's main benefit is to provide an abstraction layer that makes you more productive compared to writing SQL.
+While Prisma does allow you to [send plain SQL queries](/orm/prisma-client/queries/raw-database-access/raw-queries) to your database, it might not be the best fit if you prefer to work with a SQL-based abstraction that you want to be type-safe. Prisma's main benefit is to provide an abstraction layer that makes you more productive compared to writing SQL.
If you're a solo developer that is very comfortable with SQL, and you just want to be sure that your database layer is type-safe, a lower-level TypeScript database library might be better for you.
diff --git a/content/200-concepts/050-overview/100-what-is-prisma/100-data-modeling.mdx b/content/200-orm/050-overview/100-introduction/300-data-modeling.mdx
similarity index 96%
rename from content/200-concepts/050-overview/100-what-is-prisma/100-data-modeling.mdx
rename to content/200-orm/050-overview/100-introduction/300-data-modeling.mdx
index 38d4e000c8..ac5ff0e3a2 100644
--- a/content/200-concepts/050-overview/100-what-is-prisma/100-data-modeling.mdx
+++ b/content/200-orm/050-overview/100-introduction/300-data-modeling.mdx
@@ -179,7 +179,7 @@ The resulting `user` object is an instance of Sequelize's `Model` class (because
Depending on which parts of Prisma you want to use in your application, the data modeling flow looks slightly different. The following two sections explain the workflows for using [**only Prisma Client**](#using-only-prisma-client) and using [**Prisma Client and Prisma Migrate**](#using-prisma-client-and-prisma-migrate).
-No matter which approach though, with Prisma you never create application models in your programming language by manually defining classes, interfaces, or structs. Instead, the application models are defined in your [Prisma schema](/concepts/components/prisma-schema):
+No matter which approach though, with Prisma you never create application models in your programming language by manually defining classes, interfaces, or structs. Instead, the application models are defined in your [Prisma schema](/orm/prisma-schema):
- **Only Prisma Client**: Application models in the Prisma schema are _generated based on the introspection of your database schema_. Data modeling happens primarily on the database-level.
- **Prisma Client and Prisma Migrate**: Data modeling happens in the Prisma schema by _manually adding application models_ to it. Prisma Migrate maps these application models to tables in the underlying database (currently only supported for relational databases).
@@ -238,7 +238,7 @@ Here is an overview of the main workflow:
### Using Prisma Client and Prisma Migrate
-When using [Prisma Migrate](/concepts/components/prisma-migrate), you define your application in the Prisma schema and with relational databases use the `prisma migrate` subcommand to generate plain SQL migration files, which you can edit before applying. With MongoDB, you use `prisma db push` instead which applies the changes to your database directly.
+When using [Prisma Migrate](/orm/prisma-migrate), you define your application in the Prisma schema and with relational databases use the `prisma migrate` subcommand to generate plain SQL migration files, which you can edit before applying. With MongoDB, you use `prisma db push` instead which applies the changes to your database directly.
Here is an overview of the main workflow:
diff --git a/content/200-orm/050-overview/100-introduction/index.mdx b/content/200-orm/050-overview/100-introduction/index.mdx
new file mode 100644
index 0000000000..90a1c1af59
--- /dev/null
+++ b/content/200-orm/050-overview/100-introduction/index.mdx
@@ -0,0 +1,19 @@
+---
+title: 'Introduction'
+metaTitle: 'Introduction (Overview)'
+metaDescription: "This section gives a high-level overview of what Prisma is and how it works. It's a great starting point for Prisma newcomers!"
+---
+
+
+
+This page gives a high-level overview of what Prisma is and how it works.
+
+If you want to get started with a _practical introduction_ and learn about the Prisma Client API, head over to the [**Getting Started**](/getting-started) documentation.
+
+To learn more about the _motivation_ for Prisma, check out the [**Why Prisma?**](/orm/overview/introduction/why-prisma) page.
+
+
+
+## In this section
+
+
diff --git a/content/200-concepts/050-overview/node-js-db-tools-tradeoffs.png b/content/200-orm/050-overview/100-introduction/node-js-db-tools-tradeoffs.png
similarity index 100%
rename from content/200-concepts/050-overview/node-js-db-tools-tradeoffs.png
rename to content/200-orm/050-overview/100-introduction/node-js-db-tools-tradeoffs.png
diff --git a/content/200-concepts/050-overview/prisma-makes-devs-productive.png b/content/200-orm/050-overview/100-introduction/prisma-makes-devs-productive.png
similarity index 100%
rename from content/200-concepts/050-overview/prisma-makes-devs-productive.png
rename to content/200-orm/050-overview/100-introduction/prisma-makes-devs-productive.png
diff --git a/content/200-concepts/050-overview/prisma-rest-apis.png b/content/200-orm/050-overview/100-introduction/prisma-rest-apis.png
similarity index 100%
rename from content/200-concepts/050-overview/prisma-rest-apis.png
rename to content/200-orm/050-overview/100-introduction/prisma-rest-apis.png
diff --git a/content/200-concepts/050-overview/user-post-relation-1-n.png b/content/200-orm/050-overview/100-introduction/user-post-relation-1-n.png
similarity index 100%
rename from content/200-concepts/050-overview/user-post-relation-1-n.png
rename to content/200-orm/050-overview/100-introduction/user-post-relation-1-n.png
diff --git a/content/200-concepts/050-overview/user-table.png b/content/200-orm/050-overview/100-introduction/user-table.png
similarity index 100%
rename from content/200-concepts/050-overview/user-table.png
rename to content/200-orm/050-overview/100-introduction/user-table.png
diff --git a/content/200-concepts/050-overview/user-table.svg b/content/200-orm/050-overview/100-introduction/user-table.svg
similarity index 100%
rename from content/200-concepts/050-overview/user-table.svg
rename to content/200-orm/050-overview/100-introduction/user-table.svg
diff --git a/content/200-concepts/050-overview/300-prisma-in-your-stack/01-rest.md b/content/200-orm/050-overview/300-prisma-in-your-stack/01-rest.mdx
similarity index 93%
rename from content/200-concepts/050-overview/300-prisma-in-your-stack/01-rest.md
rename to content/200-orm/050-overview/300-prisma-in-your-stack/01-rest.mdx
index 47673b7a76..cb65d49966 100644
--- a/content/200-concepts/050-overview/300-prisma-in-your-stack/01-rest.md
+++ b/content/200-orm/050-overview/300-prisma-in-your-stack/01-rest.mdx
@@ -8,7 +8,7 @@ metaDescription: 'This page gives an overview of the most important things when
When building REST APIs, Prisma Client can be used inside your _route controllers_ to send databases queries.
-
+
@@ -31,7 +31,7 @@ Here's a non-exhaustive list of libraries and frameworks you can use with Prisma
- [Micro](https://github.com/zeit/micro)
- [Feathers](https://feathersjs.com/)
- [Remix](https://remix.run/)
-
+
## REST API server example
Assume you have a Prisma schema that looks similar to this:
@@ -63,7 +63,7 @@ model User {
}
```
-You can now implement route controller (e.g. using Express) that use the generated [Prisma Client API](/concepts/components/prisma-client) to perform a database operation when an incoming HTTP request arrives. This page only shows few sample code snippets; if you want to run these code snippets, you can use a [REST API example](https://github.com/prisma/prisma-examples/tree/latest/typescript/rest-express).
+You can now implement route controller (e.g. using Express) that use the generated [Prisma Client API](/orm/prisma-client) to perform a database operation when an incoming HTTP request arrives. This page only shows few sample code snippets; if you want to run these code snippets, you can use a [REST API example](https://github.com/prisma/prisma-examples/tree/latest/typescript/rest-express).
#### `GET`
diff --git a/content/200-concepts/050-overview/300-prisma-in-your-stack/02-graphql.md b/content/200-orm/050-overview/300-prisma-in-your-stack/02-graphql.mdx
similarity index 100%
rename from content/200-concepts/050-overview/300-prisma-in-your-stack/02-graphql.md
rename to content/200-orm/050-overview/300-prisma-in-your-stack/02-graphql.mdx
diff --git a/content/200-concepts/050-overview/300-prisma-in-your-stack/03-fullstack.mdx b/content/200-orm/050-overview/300-prisma-in-your-stack/03-fullstack.mdx
similarity index 96%
rename from content/200-concepts/050-overview/300-prisma-in-your-stack/03-fullstack.mdx
rename to content/200-orm/050-overview/300-prisma-in-your-stack/03-fullstack.mdx
index b4569bc0d5..85bd2fc921 100644
--- a/content/200-concepts/050-overview/300-prisma-in-your-stack/03-fullstack.mdx
+++ b/content/200-orm/050-overview/300-prisma-in-your-stack/03-fullstack.mdx
@@ -55,7 +55,7 @@ model User {
}
```
-You can now implement the logic for querying your database using [Prisma Client API](/concepts/components/prisma-client) inside `getServerSideProps`, `getStaticProps`, API routes, or using API libraries such as [tRPC](https://trpc.io/) and [GraphQL](https://graphql.org/).
+You can now implement the logic for querying your database using [Prisma Client API](/orm/prisma-client) inside `getServerSideProps`, `getStaticProps`, API routes, or using API libraries such as [tRPC](https://trpc.io/) and [GraphQL](https://graphql.org/).
###
getServerSideProps
diff --git a/content/200-concepts/050-overview/300-prisma-in-your-stack/04-is-prisma-an-orm.mdx b/content/200-orm/050-overview/300-prisma-in-your-stack/04-is-prisma-an-orm.mdx
similarity index 92%
rename from content/200-concepts/050-overview/300-prisma-in-your-stack/04-is-prisma-an-orm.mdx
rename to content/200-orm/050-overview/300-prisma-in-your-stack/04-is-prisma-an-orm.mdx
index d75a95daf5..274decd080 100644
--- a/content/200-concepts/050-overview/300-prisma-in-your-stack/04-is-prisma-an-orm.mdx
+++ b/content/200-orm/050-overview/300-prisma-in-your-stack/04-is-prisma-an-orm.mdx
@@ -10,7 +10,7 @@ To answer the question briefly: _Yes, Prisma is a new kind of ORM that fundament
Traditional ORMs provide an object-oriented way for working with relational databases by mapping tables to _model classes_ in your programming language. This approach leads to many problems that are caused by the [object-relational impedance mismatch](https://en.wikipedia.org/wiki/Object%E2%80%93relational_impedance_mismatch).
-Prisma works fundamentally different compared to that. With Prisma, you define your models in the declarative [Prisma schema](/concepts/components/prisma-schema) which serves as the single source of truth for your database schema and the models in your programming language. In your application code, you can then use Prisma Client to read and write data in your database in a type-safe manner without the overhead of managing complex model instances. This makes the process of querying data a lot more natural as well as more predictable since Prisma Client always returns plain JavaScript objects.
+Prisma works fundamentally different compared to that. With Prisma, you define your models in the declarative [Prisma schema](/orm/prisma-schema) which serves as the single source of truth for your database schema and the models in your programming language. In your application code, you can then use Prisma Client to read and write data in your database in a type-safe manner without the overhead of managing complex model instances. This makes the process of querying data a lot more natural as well as more predictable since Prisma Client always returns plain JavaScript objects.
In this article, you will learn in more detail about ORM patterns and workflows, how Prisma implements the Data Mapper pattern, and the benefits of Prisma's approach.
@@ -61,7 +61,7 @@ In reality, not all Data Mapper ORMs adhere to this pattern strictly. For exampl
Given the following `User` table in the database:
-
+
This is what the corresponding entity class would look like:
@@ -174,13 +174,13 @@ Now that the costs and benefits of ORMs have been covered, you can better unders
Prisma is a **next-generation ORM** that makes working with databases easy for application developers and features the following tools:
-- [**Prisma Client**](/concepts/components/prisma-client): Auto-generated and type-safe database client for use in your application.
-- [**Prisma Migrate**](/concepts/components/prisma-migrate): A declarative data modeling and migration tool.
-- [**Prisma Studio**](/concepts/components/prisma-studio): A modern GUI for browsing and managing data in your database.
+- [**Prisma Client**](/orm/prisma-client): Auto-generated and type-safe database client for use in your application.
+- [**Prisma Migrate**](/orm/prisma-migrate): A declarative data modeling and migration tool.
+- [**Prisma Studio**](/orm/tools/prisma-studio): A modern GUI for browsing and managing data in your database.
> **Note:** Since Prisma Client is the most prominent tool, we often refer to it as simply Prisma.
-The three tools use the [Prisma schema](/concepts/components/prisma-schema) as a single source of truth for the database schema, your application's object schema, and the mapping between the two. It's defined by you and is your main configuration file for Prisma.
+The three tools use the [Prisma schema](/orm/prisma-schema) as a single source of truth for the database schema, your application's object schema, and the mapping between the two. It's defined by you and is your main configuration file for Prisma.
Prisma makes you productive and confident in the software you're building with features such as _type safety_, rich auto-completion, and a natural API for fetching relations.
@@ -265,7 +265,7 @@ Here's a break down of the example above:
The `User` / `Post` relation can be visualized with the following diagram:
-
+
At a Prisma level, the `User` / `Post` relation is made up of:
@@ -281,7 +281,7 @@ In the next section, you will learn about Prisma's supported workflows.
The workflow with Prisma is slightly different to traditional ORMs. You can use Prisma when building new applications from scratch or adopt it incrementally:
- _New application_ (greenfield): Projects that have no database schema yet can use Prisma Migrate to create the database schema.
-- _Existing application_ (brownfield): Projects that already have a database schema can be [introspected](/concepts/components/introspection) by Prisma to generate the Prisma schema and Prisma Client. This use-case works with any existing migration tool and is useful for incremental adoption. It's possible to switch to Prisma Migrate as the migration tool. However, this is optional.
+- _Existing application_ (brownfield): Projects that already have a database schema can be [introspected](/orm/prisma-schema/introspection) by Prisma to generate the Prisma schema and Prisma Client. This use-case works with any existing migration tool and is useful for incremental adoption. It's possible to switch to Prisma Migrate as the migration tool. However, this is optional.
With both workflows, the Prisma schema is the main configuration file.
@@ -311,10 +311,10 @@ generator client {
```
2. Run `prisma db pull` to populate the Prisma schema with models derived from your database schema.
-3. (Optional) Customize [field and model mappings](/concepts/components/prisma-schema/data-model#mapping-model-names-to-tables-or-collections) between Prisma Client and the database.
+3. (Optional) Customize [field and model mappings](/orm/prisma-schema/data-model/models#mapping-model-names-to-tables-or-collections) between Prisma Client and the database.
4. Run `prisma generate`.
-Prisma will generate Prisma Client inside the `node_modules` folder, from which it can be imported in your application. For more extensive usage documentation, see the [Prisma Client API](/concepts/components/prisma-client) docs.
+Prisma will generate Prisma Client inside the `node_modules` folder, from which it can be imported in your application. For more extensive usage documentation, see the [Prisma Client API](/orm/prisma-client) docs.
To summarize, Prisma Client can be integrated into projects with an existing database and tooling as part of a parallel adoption strategy. New projects will use a different workflow detailed next.
@@ -430,7 +430,7 @@ With this query, `user`'s type will also include `Post`s which can be accessed w
console.log(user.posts[0].title)
```
-The example only scratches the surface of Prisma Client's API for [CRUD operations](/concepts/components/prisma-client/crud) which you can learn more about in the docs. The main idea is that all queries and results are backed by types and you have full control over how relations are fetched.
+The example only scratches the surface of Prisma Client's API for [CRUD operations](/orm/prisma-client/queries/crud) which you can learn more about in the docs. The main idea is that all queries and results are backed by types and you have full control over how relations are fetched.
## Conclusion
diff --git a/content/200-concepts/050-overview/300-prisma-in-your-stack/index.mdx b/content/200-orm/050-overview/300-prisma-in-your-stack/index.mdx
similarity index 100%
rename from content/200-concepts/050-overview/300-prisma-in-your-stack/index.mdx
rename to content/200-orm/050-overview/300-prisma-in-your-stack/index.mdx
diff --git a/content/200-concepts/100-components/database-drivers.mdx b/content/200-orm/050-overview/500-databases/200-database-drivers.mdx
similarity index 71%
rename from content/200-concepts/100-components/database-drivers.mdx
rename to content/200-orm/050-overview/500-databases/200-database-drivers.mdx
index 7297c7eaec..dcfc033995 100644
--- a/content/200-concepts/100-components/database-drivers.mdx
+++ b/content/200-orm/050-overview/500-databases/200-database-drivers.mdx
@@ -7,7 +7,7 @@ tocDepth: 4
## Default built-in drivers
-One of Prisma Client's components is the [Query Engine](./prisma-engines/query-engine)
. The Query Engine is responsible for transforming Prisma Client queries to SQL statements. The Query Engine connects to your database using the included drivers that don't require additional setup. The built-in drivers use TCP connections to connect to the database.
+One of Prisma Client's components is the [Query Engine](/orm/more/under-the-hood/engines) . The Query Engine is responsible for transforming Prisma Client queries to SQL statements. The Query Engine connects to your database using the included drivers that don't require additional setup. The built-in drivers use TCP connections to connect to the database.
@@ -28,7 +28,7 @@ There are 2 different types of driver adapters:
You can connect to your database using a Node.js-based driver from Prisma Client using a database driver adapter. Prisma maintains the following database driver adapters:
-- [Turso](/guides/database/turso#connect-and-query-your-primary-database)
+- [Turso](/orm/overview/databases/turso#how-to-connect-and-query-a-turso-database)
### Serverless driver adapters
@@ -36,8 +36,8 @@ Database providers, such as Neon and PlanetScale, allow you to connect to your d
Prisma maintains the following serverless driver adapters:
-- [Neon](/guides/database/neon#how-to-use-the-neon-serverless-driver-with-prisma-preview)
-- [PlanetScale](/guides/database/planetscale#how-to-use-the-planetscale-serverless-driver-with-prisma-preview)
+- [Neon](/orm/overview/databases/neon#how-to-use-neons-serverless-driver-with-prisma-preview)
+- [PlanetScale](/orm/overview/databases/planetscale#how-to-use-the-planetscale-serverless-driver-with-prisma-preview)
## Community maintained database driver adapters
@@ -66,6 +66,6 @@ To use this feature:
3. Refer to the following pages to learn more how to use the specific driver adapters with the specific database providers:
- - [Neon](/guides/database/neon#how-to-use-the-neon-serverless-driver-with-prisma-preview)
- - [PlanetScale](/guides/database/planetscale#how-to-use-the-planetscale-serverless-driver-with-prisma-preview)
- - [Turso](/guides/database/turso#connect-and-query-your-primary-database)
+ - [Neon](/orm/overview/databases/neon#how-to-use-neons-serverless-driver-with-prisma-preview)
+ - [PlanetScale](/orm/overview/databases/planetscale#how-to-use-the-planetscale-serverless-driver-with-prisma-preview)
+ - [Turso](/orm/overview/databases/turso#how-to-connect-and-query-a-turso-database)
diff --git a/content/200-concepts/200-database-connectors/03-postgresql.mdx b/content/200-orm/050-overview/500-databases/300-postgresql.mdx
similarity index 84%
rename from content/200-concepts/200-database-connectors/03-postgresql.mdx
rename to content/200-orm/050-overview/500-databases/300-postgresql.mdx
index 286545250f..9add3badcb 100644
--- a/content/200-concepts/200-database-connectors/03-postgresql.mdx
+++ b/content/200-orm/050-overview/500-databases/300-postgresql.mdx
@@ -1,6 +1,6 @@
---
title: 'PostgreSQL'
-metaTitle: 'PostgreSQL database connector (Reference)'
+metaTitle: 'PostgreSQL database connector'
metaDescription: 'This page explains how Prisma can connect to a PostgreSQL database using the PostgreSQL database connector.'
tocDepth: 3
---
@@ -9,13 +9,13 @@ tocDepth: 3
The PostgreSQL data source connector connects Prisma to a [PostgreSQL](https://www.postgresql.org/) database server.
-By default, the PostgreSQL connector contains a database driver responsible for connecting to your database. You can use a [driver adapter](/concepts/components/database-drivers#driver-adapters)
(Preview) to connect to your database using a JavaScript database driver from Prisma Client.
+By default, the PostgreSQL connector contains a database driver responsible for connecting to your database. You can use a [driver adapter](/orm/overview/databases/database-drivers#driver-adapters) (Preview) to connect to your database using a JavaScript database driver from Prisma Client.
## Example
-To connect to a PostgreSQL database server, you need to configure a [`datasource`](/concepts/components/prisma-schema/data-sources) block in your [Prisma schema file](/concepts/components/prisma-schema):
+To connect to a PostgreSQL database server, you need to configure a [`datasource`](/orm/prisma-schema/overview/data-sources) block in your [Prisma schema file](/orm/prisma-schema):
```prisma file=schema.prisma
datasource db {
@@ -27,7 +27,7 @@ datasource db {
The fields passed to the `datasource` block are:
- `provider`: Specifies the `postgresql` data source connector.
-- `url`: Specifies the [connection URL](#connection-url) for the PostgreSQL database server. In this case, an [environment variable is used](/concepts/components/prisma-schema#accessing-environment-variables-from-the-schema) to provide the connection URL.
+- `url`: Specifies the [connection URL](#connection-url) for the PostgreSQL database server. In this case, an [environment variable is used](/orm/prisma-schema/overview#accessing-environment-variables-from-the-schema) to provide the connection URL.
## Connection details
@@ -57,7 +57,7 @@ The following components make up the _base URL_ of your database, they are alway
-You must [percentage-encode special characters](/reference/database-reference/connection-urls#special-characters).
+You must [percentage-encode special characters](/orm/reference/connection-urls#special-characters).
@@ -71,24 +71,24 @@ postgresql://USER:PASSWORD@HOST:PORT/DATABASE?KEY1=VALUE&KEY2=VALUE&KEY3=VALUE
The following arguments can be used:
-| Argument name | Required | Default | Description |
-| :--------------------- | :------- | ---------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `schema` | **Yes** | `public` | Name of the [schema](https://www.postgresql.org/docs/12/ddl-schemas.html) you want to use, e.g. `myschema` |
-| `connection_limit` | No | `num_cpus * 2 + 1` | Maximum size of the [connection pool](/concepts/components/prisma-client/working-with-prismaclient/connection-pool) |
-| `connect_timeout` | No | `5` | Maximum number of seconds to wait for a new connection to be opened, `0` means no timeout |
-| `pool_timeout` | No | `10` | Maximum number of seconds to wait for a new connection from the pool, `0` means no timeout |
-| `sslmode` | No | `prefer` | Configures whether to use TLS. Possible values: `prefer`, `disable`, `require` |
-| `sslcert` | No | | Path of the server certificate. Certificate paths are [resolved relative to the `./prisma folder`](/concepts/components/prisma-schema/data-sources#securing-database-connections) |
-| `sslidentity` | No | | Path to the PKCS12 certificate |
-| `sslpassword` | No | | Password that was used to secure the PKCS12 file |
-| `sslaccept` | No | `accept_invalid_certs` | Configures whether to check for missing values in the certificate. Possible values: `accept_invalid_certs`, `strict` |
-| `host` | No | | Points to a directory that contains a socket to be used for the connection |
-| `socket_timeout` | No | | Maximum number of seconds to wait until a single query terminates |
-| `pgbouncer` | No | `false` | Configure the Engine to [enable PgBouncer compatibility mode](/guides/performance-and-optimization/connection-management/configure-pg-bouncer) |
-| `statement_cache_size` | No | `500` | Since 2.1.0: Specifies the number of [prepared statements](#prepared-statement-caching) cached per connection |
-| `application_name` | No | | Since 3.3.0: Specifies a value for the application_name configuration parameter |
-| `channel_binding` | No | `prefer` | Since 4.8.0: Specifies a value for the channel_binding configuration parameter |
-| `options` | No | | Since 3.8.0: Specifies command line options to send to the server at connection start |
+| Argument name | Required | Default | Description |
+| :--------------------- | :------- | ---------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `schema` | **Yes** | `public` | Name of the [schema](https://www.postgresql.org/docs/12/ddl-schemas.html) you want to use, e.g. `myschema` |
+| `connection_limit` | No | `num_cpus * 2 + 1` | Maximum size of the [connection pool](/orm/prisma-client/setup-and-configuration/databases-connections/connection-pool) |
+| `connect_timeout` | No | `5` | Maximum number of seconds to wait for a new connection to be opened, `0` means no timeout |
+| `pool_timeout` | No | `10` | Maximum number of seconds to wait for a new connection from the pool, `0` means no timeout |
+| `sslmode` | No | `prefer` | Configures whether to use TLS. Possible values: `prefer`, `disable`, `require` |
+| `sslcert` | No | | Path of the server certificate. Certificate paths are [resolved relative to the `./prisma folder`](/orm/prisma-schema/overview/data-sources#securing-database-connections) |
+| `sslidentity` | No | | Path to the PKCS12 certificate |
+| `sslpassword` | No | | Password that was used to secure the PKCS12 file |
+| `sslaccept` | No | `accept_invalid_certs` | Configures whether to check for missing values in the certificate. Possible values: `accept_invalid_certs`, `strict` |
+| `host` | No | | Points to a directory that contains a socket to be used for the connection |
+| `socket_timeout` | No | | Maximum number of seconds to wait until a single query terminates |
+| `pgbouncer` | No | `false` | Configure the Engine to [enable PgBouncer compatibility mode](/orm/prisma-client/setup-and-configuration/databases-connections/pgbouncer) |
+| `statement_cache_size` | No | `500` | Since 2.1.0: Specifies the number of [prepared statements](#prepared-statement-caching) cached per connection |
+| `application_name` | No | | Since 3.3.0: Specifies a value for the application_name configuration parameter |
+| `channel_binding` | No | `prefer` | Since 4.8.0: Specifies a value for the channel_binding configuration parameter |
+| `options` | No | | Since 3.8.0: Specifies command line options to send to the server at connection start |
As an example, if you want to connect to a schema called `myschema`, set the connection pool size to `5` and configure a timeout for queries of `3` seconds. You can use the following arguments:
@@ -104,7 +104,7 @@ You can add various parameters to the connection URL if your database server use
- `prefer` (default): Prefer TLS if possible, accept plain text connections.
- `disable`: Do not use TLS.
- `require`: Require TLS or fail if not possible.
-- `sslcert=
`: Path to the server certificate. This is the root certificate used by the database server to sign the client certificate. You need to provide this if the certificate doesn't exist in the trusted certificate store of your system. For Google Cloud this likely is `server-ca.pem`. Certificate paths are [resolved relative to the `./prisma folder`](/concepts/components/prisma-schema/data-sources#securing-database-connections)
+- `sslcert=`: Path to the server certificate. This is the root certificate used by the database server to sign the client certificate. You need to provide this if the certificate doesn't exist in the trusted certificate store of your system. For Google Cloud this likely is `server-ca.pem`. Certificate paths are [resolved relative to the `./prisma folder`](/orm/prisma-schema/overview/data-sources#securing-database-connections)
- `sslidentity=`: Path to the PKCS12 certificate database created from client cert and key. This is the SSL identity file in PKCS12 format which you will generate using the client key and client certificate. It combines these two files in a single file and secures them via a password (see next parameter). You can create this file using your client key and client certificate by using the following command (using `openssl`):
```
openssl pkcs12 -export -out client-identity.p12 -inkey client-key.pem -in client-cert.pem
@@ -133,11 +133,11 @@ Note that `localhost` is required, the value itself is ignored and can be anythi
These two tables show the type mapping between PostgreSQL and Prisma schema. First [how Prisma scalar types are translated into PostgreSQL database column types](#mapping-between-prisma-scalar-types-and-postgresql-database-column-types), and then [how PostgreSQL database column types relate to Prisma scalar and native types](#mapping-between-postgresql-database-column-types-to-prisma-scalar-and-native-types).
-> Alternatively, see [Prisma schema reference](/reference/api-reference/prisma-schema-reference#model-field-scalar-types) for type mappings organized by Prisma type.
+> Alternatively, see [Prisma schema reference](/orm/reference/prisma-schema-reference#model-field-scalar-types) for type mappings organized by Prisma type.
### Mapping between Prisma scalar types and PostgreSQL database column types
-The PostgreSQL connector maps the [scalar types](/concepts/components/prisma-schema/data-model#scalar-fields) from the Prisma [data model](/concepts/components/prisma-schema/data-model) as follows to database column types:
+The PostgreSQL connector maps the [scalar types](/orm/prisma-schema/data-model/models#scalar-fields) from the Prisma [data model](/orm/prisma-schema/data-model/models) as follows to database column types:
| Prisma | PostgreSQL |
| ---------- | ------------------ |
@@ -153,29 +153,29 @@ The PostgreSQL connector maps the [scalar types](/concepts/components/prisma-sch
### Mapping between PostgreSQL database column types to Prisma scalar and native types
-- When [introspecting](/concepts/components/introspection) a PostgreSQL database, the database types are mapped to Prisma types according to the following table.
-- When [creating a migration](/concepts/components/prisma-migrate) or [prototyping your schema](/concepts/components/prisma-migrate/db-push) the table is also used - in the other direction.
+- When [introspecting](/orm/prisma-schema/introspection) a PostgreSQL database, the database types are mapped to Prisma types according to the following table.
+- When [creating a migration](/orm/prisma-migrate) or [prototyping your schema](/orm/prisma-migrate/workflows/prototyping-your-schema) the table is also used - in the other direction.
-| PostgreSQL (Type \| Aliases) | Supported | Prisma | Native database type attribute | Notes |
-| ------------------------------------------- | :-------: | ------------- | :--------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `bigint` \| `int8` | ✔️ | `BigInt` | `@db.BigInt`\* | \*Default mapping for `BigInt` - no type attribute added to schema. |
-| `boolean` \| `bool` | ✔️ | `Bool` | `@db.Boolean`\* | \*Default mapping for `Bool` - no type attribute added to schema. |
+| PostgreSQL (Type \| Aliases) | Supported | Prisma | Native database type attribute | Notes |
+| ------------------------------------------- | :-------: | ------------- | :--------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `bigint` \| `int8` | ✔️ | `BigInt` | `@db.BigInt`\* | \*Default mapping for `BigInt` - no type attribute added to schema. |
+| `boolean` \| `bool` | ✔️ | `Bool` | `@db.Boolean`\* | \*Default mapping for `Bool` - no type attribute added to schema. |
| `timestamp with time zone` \| `timestamptz` | ✔️ | `DateTime` | `@db.Timestamptz(x)` |
| `time without time zone` \| `time` | ✔️ | `DateTime` | `@db.Time(x)` |
| `time with time zone` \| `timetz` | ✔️ | `DateTime` | `@db.Timetz(x)` |
| `numeric(p,s)` \| `decimal(p,s)` | ✔️ | `Decimal` | `@db.Decimal(x, y)` |
| `real` \| `float`, `float4` | ✔️ | `Float` | `@db.Real` |
-| `double precision` \| `float8` | ✔️ | `Float` | `@db.DoublePrecision`\* | \*Default mapping for `Float` - no type attribute added to schema. |
-| `smallint` \| `int2` | ✔️ | `Int` | `@db.SmallInt` | |
-| `integer` \| `int`, `int4` | ✔️ | `Int` | `@db.Int`\* | \*Default mapping for `Int` - no type attribute added to schema. |
+| `double precision` \| `float8` | ✔️ | `Float` | `@db.DoublePrecision`\* | \*Default mapping for `Float` - no type attribute added to schema. |
+| `smallint` \| `int2` | ✔️ | `Int` | `@db.SmallInt` | |
+| `integer` \| `int`, `int4` | ✔️ | `Int` | `@db.Int`\* | \*Default mapping for `Int` - no type attribute added to schema. |
| `smallserial` \| `serial2` | ✔️ | `Int` | `@db.SmallInt @default(autoincrement())` |
| `serial` \| `serial4` | ✔️ | `Int` | `@db.Int @default(autoincrement())` |
| `bigserial` \| `serial8` | ✔️ | `Int` | `@db.BigInt @default(autoincrement()` |
| `character(n)` \| `char(n)` | ✔️ | `String` | `@db.Char(x)` |
| `character varying(n)` \| `varchar(n)` | ✔️ | `String` | `@db.VarChar(x)` |
| `money` | ✔️ | `Decimal` | `@db.Money` |
-| `text` | ✔️ | `String` | `@db.Text`\* | \*Default mapping for `String` - no type attribute added to schema. |
-| `timestamp` | ✔️ | `DateTime` | `@db.TimeStamp`\* | \*Default mapping for `DateTime` - no type attribute added to schema. |
+| `text` | ✔️ | `String` | `@db.Text`\* | \*Default mapping for `String` - no type attribute added to schema. |
+| `timestamp` | ✔️ | `DateTime` | `@db.TimeStamp`\* | \*Default mapping for `DateTime` - no type attribute added to schema. |
| `date` | ✔️ | `DateTime` | `@db.Date` |
| `enum` | ✔️ | `Enum` | N/A |
| `inet` | ✔️ | `String` | `@db.Inet` |
@@ -184,33 +184,33 @@ The PostgreSQL connector maps the [scalar types](/concepts/components/prisma-sch
| `oid` | ✔️ | `Int` | `@db.Oid` |
| `uuid` | ✔️ | `String` | `@db.Uuid` |
| `json` | ✔️ | `Json` | `@db.Json` |
-| `jsonb` | ✔️ | `Json` | `@db.JsonB`\* | \*Default mapping for `Json` - no type attribute added to schema. |
-| `bytea` | ✔️ | `Bytes` | `@db.ByteA`\* | \*Default mapping for `Bytes` - no type attribute added to schema. |
+| `jsonb` | ✔️ | `Json` | `@db.JsonB`\* | \*Default mapping for `Json` - no type attribute added to schema. |
+| `bytea` | ✔️ | `Bytes` | `@db.ByteA`\* | \*Default mapping for `Bytes` - no type attribute added to schema. |
| `xml` | ✔️ | `String` | `@db.Xml` |
| Array types | ✔️ | `[]` |
-| `citext` | ✔️\* | `String` | `@db.Citext` | \* Only available if [Citext extension is enabled](/concepts/components/prisma-schema/features-without-psl-equivalent#enable-postgresql-extensions-for-native-database-functions). |
-| `interval` | Not yet | `Unsupported` | | |
-| `cidr` | Not yet | `Unsupported` | | |
-| `macaddr` | Not yet | `Unsupported` | | |
-| `tsvector` | Not yet | `Unsupported` | | |
-| `tsquery` | Not yet | `Unsupported` | | |
-| `int4range` | Not yet | `Unsupported` | | |
-| `int8range` | Not yet | `Unsupported` | | |
-| `numrange` | Not yet | `Unsupported` | | |
-| `tsrange` | Not yet | `Unsupported` | | |
-| `tstzrange` | Not yet | `Unsupported` | | |
-| `daterange` | Not yet | `Unsupported` | | |
-| `point` | Not yet | `Unsupported` | | |
-| `line` | Not yet | `Unsupported` | | |
-| `lseg` | Not yet | `Unsupported` | | |
-| `box` | Not yet | `Unsupported` | | |
-| `path` | Not yet | `Unsupported` | | |
-| `polygon` | Not yet | `Unsupported` | | |
-| `circle` | Not yet | `Unsupported` | | |
-| Composite types | Not yet | n/a | | |
-| Domain types | Not yet | n/a | | |
-
-[Introspection](/concepts/components/introspection) adds native database types that are **not yet supported** as [`Unsupported`](/reference/api-reference/prisma-schema-reference#unsupported) fields:
+| `citext` | ✔️\* | `String` | `@db.Citext` | \* Only available if [Citext extension is enabled](/orm/prisma-schema/data-model/unsupported-database-features#enable-postgresql-extensions-for-native-database-functions). |
+| `interval` | Not yet | `Unsupported` | | |
+| `cidr` | Not yet | `Unsupported` | | |
+| `macaddr` | Not yet | `Unsupported` | | |
+| `tsvector` | Not yet | `Unsupported` | | |
+| `tsquery` | Not yet | `Unsupported` | | |
+| `int4range` | Not yet | `Unsupported` | | |
+| `int8range` | Not yet | `Unsupported` | | |
+| `numrange` | Not yet | `Unsupported` | | |
+| `tsrange` | Not yet | `Unsupported` | | |
+| `tstzrange` | Not yet | `Unsupported` | | |
+| `daterange` | Not yet | `Unsupported` | | |
+| `point` | Not yet | `Unsupported` | | |
+| `line` | Not yet | `Unsupported` | | |
+| `lseg` | Not yet | `Unsupported` | | |
+| `box` | Not yet | `Unsupported` | | |
+| `path` | Not yet | `Unsupported` | | |
+| `polygon` | Not yet | `Unsupported` | | |
+| `circle` | Not yet | `Unsupported` | | |
+| Composite types | Not yet | n/a | | |
+| Domain types | Not yet | n/a | | |
+
+[Introspection](/orm/prisma-schema/introspection) adds native database types that are **not yet supported** as [`Unsupported`](/orm/reference/prisma-schema-reference#unsupported) fields:
```prisma file=schema.prisma
model Device {
@@ -224,10 +224,9 @@ model Device {
A [prepared statement](https://www.postgresql.org/docs/current/sql-prepare.html) is a feature that can be used to optimize performance. A prepared statement is parsed, compiled, and optimized only once and then can be executed directly multiple times without the overhead of parsing the query again.
-By caching prepared statements, Prisma Client's [query engine](https://www.prisma.io/docs/concepts/components/prisma-engines/query-engine) does not repeatedly compile the same query which reduces database CPU usage and query latency.
+By caching prepared statements, Prisma Client's [query engine](/orm/more/under-the-hood/engines) does not repeatedly compile the same query which reduces database CPU usage and query latency.
-
-For example, here is the generated SQL for two different queries made by Prisma Client:
+For example, here is the generated SQL for two different queries made by Prisma Client:
```sql
SELECT * FROM user WHERE name = "John";
@@ -240,7 +239,6 @@ The two queries after parameterization will be the same, and the second query ca
SELECT * FROM user WHERE name = $1
```
-
Every database connection maintained by Prisma has a separate cache for storing prepared statements. The size of this cache can be tweaked with the `statement_cache_size` parameter in the connection string. By default, Prisma Client caches 500 statements per connection.
Due to the nature of pgBouncer, if the `pgbouncer` parameter is set to `true`, the prepared statement cache is automatically disabled for that connection.
diff --git a/content/200-concepts/200-database-connectors/04-mysql.mdx b/content/200-orm/050-overview/500-databases/400-mysql.mdx
similarity index 87%
rename from content/200-concepts/200-database-connectors/04-mysql.mdx
rename to content/200-orm/050-overview/500-databases/400-mysql.mdx
index 3fe1615cb9..cabbaee1e0 100644
--- a/content/200-concepts/200-database-connectors/04-mysql.mdx
+++ b/content/200-orm/050-overview/500-databases/400-mysql.mdx
@@ -1,6 +1,6 @@
---
title: 'MySQL'
-metaTitle: 'MySQL database connector (Reference)'
+metaTitle: 'MySQL database connector'
metaDescription: 'This page explains how Prisma can connect to a MySQL database using the MySQL database connector.'
tocDepth: 3
---
@@ -9,13 +9,13 @@ tocDepth: 3
The MySQL data source connector connects Prisma to a [MySQL](https://www.mysql.com/) database server.
-By default, the MySQL connector contains a database driver responsible for connecting to your database. You can use a [driver adapter](/concepts/components/database-drivers#driver-adapters) (Preview) to connect to your database using a JavaScript database driver from Prisma Client.
+By default, the MySQL connector contains a database driver responsible for connecting to your database. You can use a [driver adapter](/orm/overview/databases/database-drivers#driver-adapters) (Preview) to connect to your database using a JavaScript database driver from Prisma Client.
## Example
-To connect to a MySQL database server, you need to configure a [`datasource`](/concepts/components/prisma-schema/data-sources) block in your [Prisma schema file](/concepts/components/prisma-schema):
+To connect to a MySQL database server, you need to configure a [`datasource`](/orm/prisma-schema/overview/data-sources) block in your [Prisma schema file](/orm/prisma-schema):
```prisma file=schema.prisma
datasource db {
@@ -27,7 +27,7 @@ datasource db {
The fields passed to the `datasource` block are:
- `provider`: Specifies the `mysql` data source connector.
-- `url`: Specifies the [connection URL](#connection-url) for the MySQL database server. In this case, an [environment variable is used](/concepts/components/prisma-schema#accessing-environment-variables-from-the-schema) to provide the connection URL.
+- `url`: Specifies the [connection URL](#connection-url) for the MySQL database server. In this case, an [environment variable is used](/orm/prisma-schema/overview#accessing-environment-variables-from-the-schema) to provide the connection URL.
## Connection details
@@ -57,7 +57,7 @@ The following components make up the _base URL_ of your database, they are alway
-You must [percentage-encode special characters](/reference/database-reference/connection-urls#special-characters).
+You must [percentage-encode special characters](/orm/reference/connection-urls#special-characters).
@@ -71,17 +71,17 @@ mysql://USER:PASSWORD@HOST:PORT/DATABASE?KEY1=VALUE&KEY2=VALUE&KEY3=VALUE
The following arguments can be used:
-| Argument name | Required | Default | Description |
-| :----------------- | :------- | ---------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `connection_limit` | No | `num_cpus * 2 + 1` | Maximum size of the [connection pool](/concepts/components/prisma-client/working-with-prismaclient/connection-pool) |
-| `connect_timeout` | No | `5` | Maximum number of seconds to wait for a new connection to be opened, `0` means no timeout |
-| `pool_timeout` | No | `10` | Maximum number of seconds to wait for a new connection from the pool, `0` means no timeout |
-| `sslcert` | No | | Path to the server certificate. Certificate paths are [resolved relative to the `./prisma folder`](/concepts/components/prisma-schema/data-sources#securing-database-connections) |
-| `sslidentity` | No | | Path to the PKCS12 certificate |
-| `sslpassword` | No | | Password that was used to secure the PKCS12 file |
-| `sslaccept` | No | `accept_invalid_certs` | Configures whether to check for missing values in the certificate. Possible values: `accept_invalid_certs`, `strict` |
-| `socket` | No | | Points to a directory that contains a socket to be used for the connection |
-| `socket_timeout` | No | | Number of seconds to wait until a single query terminates |
+| Argument name | Required | Default | Description |
+| :----------------- | :------- | ---------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `connection_limit` | No | `num_cpus * 2 + 1` | Maximum size of the [connection pool](/orm/prisma-client/setup-and-configuration/databases-connections/connection-pool) |
+| `connect_timeout` | No | `5` | Maximum number of seconds to wait for a new connection to be opened, `0` means no timeout |
+| `pool_timeout` | No | `10` | Maximum number of seconds to wait for a new connection from the pool, `0` means no timeout |
+| `sslcert` | No | | Path to the server certificate. Certificate paths are [resolved relative to the `./prisma folder`](/orm/prisma-schema/overview/data-sources#securing-database-connections) |
+| `sslidentity` | No | | Path to the PKCS12 certificate |
+| `sslpassword` | No | | Password that was used to secure the PKCS12 file |
+| `sslaccept` | No | `accept_invalid_certs` | Configures whether to check for missing values in the certificate. Possible values: `accept_invalid_certs`, `strict` |
+| `socket` | No | | Points to a directory that contains a socket to be used for the connection |
+| `socket_timeout` | No | | Number of seconds to wait until a single query terminates |
As an example, if you want to set the connection pool size to `5` and configure a timeout for queries of `3` seconds, you can use the following arguments:
@@ -93,7 +93,7 @@ mysql://USER:PASSWORD@HOST:PORT/DATABASE?connection_limit=5&socket_timeout=3
You can add various parameters to the connection URL if your database server uses SSL. Here's an overview of the possible parameters:
-- `sslcert=`: Path to the server certificate. This is the root certificate used by the database server to sign the client certificate. You need to provide this if the certificate doesn't exist in the trusted certificate store of your system. For Google Cloud this likely is `server-ca.pem`. Certificate paths are [resolved relative to the `./prisma folder`](/concepts/components/prisma-schema/data-sources#securing-database-connections)
+- `sslcert=`: Path to the server certificate. This is the root certificate used by the database server to sign the client certificate. You need to provide this if the certificate doesn't exist in the trusted certificate store of your system. For Google Cloud this likely is `server-ca.pem`. Certificate paths are [resolved relative to the `./prisma folder`](/orm/prisma-schema/overview/data-sources#securing-database-connections)
- `sslidentity=`: Path to the PKCS12 certificate database created from client cert and key. This is the SSL identity file in PKCS12 format which you will generate using the client key and client certificate. It combines these two files in a single file and secures them via a password (see next parameter). You can create this file using your client key and client certificate by using the following command (using `openssl`):
```
@@ -121,9 +121,9 @@ Note that `localhost` is required, the value itself is ignored and can be anythi
## Type mapping between MySQL to Prisma schema
-The MySQL connector maps the [scalar types](/concepts/components/prisma-schema/data-model#scalar-fields) from the Prisma [data model](/concepts/components/prisma-schema/data-model) as follows to native column types:
+The MySQL connector maps the [scalar types](/orm/prisma-schema/data-model/models#scalar-fields) from the Prisma [data model](/orm/prisma-schema/data-model/models) as follows to native column types:
-> Alternatively, see [Prisma schema reference](/reference/api-reference/prisma-schema-reference#model-field-scalar-types) for type mappings organized by Prisma type.
+> Alternatively, see [Prisma schema reference](/orm/reference/prisma-schema-reference#model-field-scalar-types) for type mappings organized by Prisma type.
### Native type mapping from Prisma to MySQL
@@ -191,7 +191,7 @@ When introspecting a MySQL database, the database types are mapped to Prisma acc
| `multipolygon` | `Unsupported` | Not yet | |
| `geometrycollection` | `Unsupported` | Not yet | |
-[Introspection](/concepts/components/introspection) adds native database types that are **not yet supported** as [`Unsupported`](/reference/api-reference/prisma-schema-reference#unsupported) fields:
+[Introspection](/orm/prisma-schema/introspection) adds native database types that are **not yet supported** as [`Unsupported`](/orm/reference/prisma-schema-reference#unsupported) fields:
```prisma file=schema.prisma
model Device {
diff --git a/content/200-concepts/200-database-connectors/05-sqlite.mdx b/content/200-orm/050-overview/500-databases/500-sqlite.mdx
similarity index 70%
rename from content/200-concepts/200-database-connectors/05-sqlite.mdx
rename to content/200-orm/050-overview/500-databases/500-sqlite.mdx
index 26fa6c104f..fc31ca5d47 100644
--- a/content/200-concepts/200-database-connectors/05-sqlite.mdx
+++ b/content/200-orm/050-overview/500-databases/500-sqlite.mdx
@@ -1,6 +1,6 @@
---
title: 'SQLite'
-metaTitle: 'SQLite database connector (Reference)'
+metaTitle: 'SQLite database connector'
metaDescription: 'This page explains how Prisma can connect to a SQLite database using the SQLite database connector.'
tocDepth: 3
---
@@ -9,13 +9,13 @@ tocDepth: 3
The SQLite data source connector connects Prisma to a [SQLite](https://www.sqlite.org/) database file. These files always have the file ending `.db` (e.g.: `dev.db`).
-By default, the SQLite connector contains a database driver responsible for connecting to your database. You can use a [driver adapter](/concepts/components/database-drivers#driver-adapters) (Preview) to connect to your database using a JavaScript database driver from Prisma Client.
+By default, the SQLite connector contains a database driver responsible for connecting to your database. You can use a [driver adapter](/orm/overview/databases/database-drivers#driver-adapters) (Preview) to connect to your database using a JavaScript database driver from Prisma Client.
## Example
-To connect to a SQLite database file, you need to configure a [`datasource`](/concepts/components/prisma-schema/data-sources) block in your [schema file](/concepts/components/prisma-schema):
+To connect to a SQLite database file, you need to configure a [`datasource`](/orm/prisma-schema/overview/data-sources) block in your [schema file](/orm/prisma-schema):
```prisma file=schema.prisma
datasource db {
@@ -27,13 +27,13 @@ datasource db {
The fields passed to the `datasource` block are:
- `provider`: Specifies the `sqlite` data source connector.
-- `url`: Specifies the [connection URL](/reference/database-reference/connection-urls) for the SQLite database. The connection URL always starts with the prefix `file:` and then contains a file path pointing to the SQLite database file. In this case, the file is located in the same directory and called `dev.db`.
+- `url`: Specifies the [connection URL](/orm/reference/connection-urls) for the SQLite database. The connection URL always starts with the prefix `file:` and then contains a file path pointing to the SQLite database file. In this case, the file is located in the same directory and called `dev.db`.
## Type mapping between SQLite to Prisma schema
-The SQLite connector maps the [scalar types](/concepts/components/prisma-schema/data-model#scalar-fields) from the [data model](/concepts/components/prisma-schema/data-model) to native column types as follows:
+The SQLite connector maps the [scalar types](/orm/prisma-schema/data-model/models#scalar-fields) from the [data model](/orm/prisma-schema/data-model/models) to native column types as follows:
-> Alternatively, see [Prisma schema reference](/reference/api-reference/prisma-schema-reference#model-field-scalar-types) for type mappings organized by Prisma type.
+> Alternatively, see [Prisma schema reference](/orm/reference/prisma-schema-reference#model-field-scalar-types) for type mappings organized by Prisma type.
### Native type mapping from Prisma to SQLite
diff --git a/content/300-guides/050-database/870-mongodb.mdx b/content/200-orm/050-overview/500-databases/600-mongodb.mdx
similarity index 50%
rename from content/300-guides/050-database/870-mongodb.mdx
rename to content/200-orm/050-overview/500-databases/600-mongodb.mdx
index 48ee2c0e88..8f1f9fee79 100644
--- a/content/300-guides/050-database/870-mongodb.mdx
+++ b/content/200-orm/050-overview/500-databases/600-mongodb.mdx
@@ -1,15 +1,22 @@
---
-title: 'Using Prisma with MongoDB'
-metaTitle: 'Using Prisma with MongoDB'
-metaDescription: 'Guide to using Prisma with MongoDB'
+title: 'MongoDB'
+metaTitle: 'MongoDB database connector'
+metaDescription: 'How Prisma can connect to a MongoDB database using the MongoDB database connector.'
+hidePage: false
tocDepth: 3
-toc: true
+codeStyle: false
---
This guide discusses the concepts behind using Prisma and MongoDB, explains the commonalities and differences between MongoDB and other database providers, and leads you through the process for configuring your application to integrate with MongoDB using Prisma.
+
+
+To connect Prisma with MongoDB, refer to our [Getting Started documentation](/getting-started/setup-prisma/start-from-scratch/mongodb-typescript-mongodb).
+
+
+
## What is MongoDB?
@@ -22,17 +29,17 @@ MongoDB stores data in collections that do not need a schema to be defined in ad
Some aspects of using Prisma with MongoDB are the same as when using Prisma with a relational database. You can still:
-- model your database with the [Prisma Schema Language](/concepts/components/prisma-schema)
-- connect to your database, using the [`mongodb` database connector](/concepts/database-connectors/mongodb)
-- use [Introspection](/concepts/components/introspection) for existing projects if you already have a MongoDB database
-- use [`db push`](/concepts/components/prisma-migrate/db-push) to push changes in your schema to the database
-- use [Prisma Client](/concepts/components/prisma-client) in your application to query your database in a type safe way based on your Prisma Schema
+- model your database with the [Prisma Schema Language](/orm/prisma-schema)
+- connect to your database, using the [`mongodb` database connector](/orm/overview/databases)
+- use [Introspection](/orm/prisma-schema/introspection) for existing projects if you already have a MongoDB database
+- use [`db push`](/orm/prisma-migrate/workflows/prototyping-your-schema) to push changes in your schema to the database
+- use [Prisma Client](/orm/prisma-client) in your application to query your database in a type safe way based on your Prisma Schema
## Differences to consider
MongoDB's document-based structure and flexible schemas means that using Prisma with MongoDB differs from using it with a relational database in a number of ways. These are some areas where there are differences that you need to be aware of:
-- **Defining IDs**: MongoDB documents have an `_id` field (that often contains an [ObjectID](https://www.mongodb.com/docs/manual/reference/bson-types/#std-label-objectid)). Prisma does not support fields starting with `_`, so this needs to be mapped to a Prisma field using the `@map` attribute. For more information, see [Defining IDs in MongoDB](/concepts/components/prisma-schema/data-model#defining-ids-in-mongodb).
+- **Defining IDs**: MongoDB documents have an `_id` field (that often contains an [ObjectID](https://www.mongodb.com/docs/manual/reference/bson-types/#std-label-objectid)). Prisma does not support fields starting with `_`, so this needs to be mapped to a Prisma field using the `@map` attribute. For more information, see [Defining IDs in MongoDB](/orm/prisma-schema/data-model/models#defining-ids-in-mongodb).
- **Migrating existing data to match your Prisma schema**: In relational databases, all your data must match your schema. If you change the type of a particular field in your schema when you migrate, all the data must also be updated to match. In contrast, MongoDB does not enforce any particular schema, so you need to take care when migrating. For more information, see [How to migrate old data to new schemas](#how-to-migrate-existing-data-to-match-your-prisma-schema).
@@ -150,7 +157,7 @@ model User {
}
```
-For more information on how to use relations in Prisma, see [our documentation](/concepts/components/prisma-schema/relations).
+For more information on how to use relations in Prisma, see [our documentation](/orm/prisma-schema/data-model/relations).
### How to filter for null and missing fields
@@ -283,7 +290,7 @@ console.log(findNulls)
This is because `name: null` is checking for equality, and a non-existing field isn't equal to `null`.
-To include missing fields as well, use the [`isSet` filter](/reference/api-reference/prisma-client-reference#isset) to explicitly search for fields which are either `null` or not set. This will return both records:
+To include missing fields as well, use the [`isSet` filter](/orm/reference/prisma-client-reference#isset) to explicitly search for fields which are either `null` or not set. This will return both records:
@@ -339,6 +346,230 @@ The fastest way to start using MongoDB with Prisma is to refer to our Getting St
These tutorials will take you through the process of connecting to MongoDB, pushing schema changes, and using Prisma Client.
-Further reference information is available in the [MongoDB connector documentation](/concepts/database-connectors/mongodb).
+Further reference information is available in the [MongoDB connector documentation](/orm/overview/databases/mongodb).
For more information on how to set up and manage a MongoDB database, see the [Prisma Data Guide](https://www.prisma.io/dataguide#mongodb).
+
+## Example
+
+To connect to a MongoDB server, configure the [`datasource`](/orm/prisma-schema/overview/data-sources) block in your [Prisma schema file](/orm/prisma-schema):
+
+```prisma file=schema.prisma
+datasource db {
+ provider = "mongodb"
+ url = env("DATABASE_URL")
+}
+```
+
+The fields passed to the `datasource` block are:
+
+- `provider`: Specifies the `mongodb` data source connector.
+- `url`: Specifies the [connection URL](#connection-url) for the MongoDB server. In this case, an [environment variable is used](/orm/more/development-environment/environment-variables) to provide the connection URL.
+
+
+
+The MongoDB database connector uses transactions to support nested writes. Transactions **require** a [replica set](https://docs.mongodb.com/manual/tutorial/deploy-replica-set/) deployment. The easiest way to deploy a replica set is with [Atlas](https://docs.atlas.mongodb.com/getting-started/). It's free to get started.
+
+
+
+## Connection details
+
+### Connection URL
+
+The MongoDB connection URL can be configured in different ways depending on how you are hosting your database. The standard configuration is made up of the following components:
+
+
+
+#### Base URL and path
+
+The base URL and path sections of the connection URL are made up of your authentication credentials followed by the host (and optionally, a port number) and database.
+
+```
+mongodb://USERNAME:PASSWORD@HOST/DATABASE
+```
+
+The following components make up the _base URL_ of your database:
+
+| Name | Placeholder | Description |
+| :------- | :---------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| User | `USERNAME` | Name of your database user, e.g. `janedoe` |
+| Password | `PASSWORD` | Password for your database user |
+| Host | `HOST` | The host where a [`mongod`](https://docs.mongodb.com/manual/reference/program/mongod/#mongodb-binary-bin.mongod) instance is running. If you are running a sharded cluster this will a [`mongos`](https://docs.mongodb.com/manual/reference/program/mongos/#mongodb-binary-bin.mongos) instance. This can be a hostname, IP address or UNIX domain socket. |
+| Port | `PORT` | Port on which your database server is running, e.g. `1234`. If none is provided the default `27017` is used. |
+| Database | `DATABASE` | Name of the database to use. If none is specified but the `authSource` option is set then the `authSource` database name is used. If neither the database in the connection string nor the `authSource` option is specified then it defaults to `admin` |
+
+
+
+You must [percentage-encode special characters](/orm/reference/connection-urls#special-characters).
+
+
+
+#### Arguments
+
+A connection URL can also take arguments. The following example sets three arguments:
+
+- An `ssl` connection
+- A `connectTimeoutMS`
+- And the `maxPoolSize`
+
+```
+mongodb://USERNAME:PASSWORD@HOST/DATABASE?ssl=true&connectTimeoutMS=5000&maxPoolSize=50
+```
+
+Refer to the [MongoDB connection string documentation](https://docs.mongodb.com/manual/reference/connection-string/#connection-string-options) for a complete list of connection string arguments. There are no Prisma-specific arguments.
+
+## Using ObjectId
+
+It is common practice for the `_id` field of a MongoDB document to contain an [ObjectId](https://docs.mongodb.com/manual/reference/bson-types/#std-label-objectid):
+
+```json
+{
+ "_id": { "$oid": "60d599cb001ef98000f2cad2" },
+ "createdAt": { "$date": { "$numberLong": "1624611275577" } },
+ "email": "ella@prisma.io",
+ "name": "Ella",
+ "role": "ADMIN"
+}
+```
+
+Any field (most commonly IDs and relation scalar fields) that maps to an `ObjectId` in the underlying database:
+
+- Must be of type `String` or `Bytes`
+- Must include the `@db.ObjectId` attribute
+- Can optionally use `@default(auto())` to auto-generate a valid `ObjectId` on document creation
+
+Here is an example that uses `String`:
+
+```prisma
+model User {
+ id String @id @default(auto()) @map("_id") @db.ObjectId
+ // Other fields
+}
+```
+
+And here is another example that uses `Bytes`:
+
+```prisma
+model User {
+ id Bytes @id @default(auto()) @map("_id") @db.ObjectId
+ // Other fields
+}
+```
+
+See also: [Defining ID fields in MongoDB](/orm/prisma-schema/data-model/models#defining-ids-in-mongodb)
+
+### Generating `ObjectId`
+
+To generate a valid `ObjectId` (for testing purposes or to manually set an ID field value) in your application, use the [`bson`](https://www.npmjs.com/package/bson) package.
+
+```
+npm install --save bson
+```
+
+```ts
+import { ObjectId } from 'bson'
+
+const id = new ObjectId()
+```
+
+## Differences to connectors for relational databases
+
+This section covers ways in which the MongoDB connector differs from Prisma connectors for relational databases.
+
+### No support for Prisma Migrate
+
+Currently, there are no plans to add support for [Prisma Migrate](/orm/prisma-migrate) as MongoDB projects do not rely on internal schemas where changes need to be managed with an extra tool. Management of `@unique` indexes is realized through `db push`.
+
+### No support for @@id and autoincrement()
+
+The [`@@id`](/orm/reference/prisma-schema-reference#id-1) attribute (an ID for multiple fields) is not supported because primary keys in MongoDB are always on the `_id` field of a model.
+
+The [`autoincrement()`](/orm/reference/prisma-schema-reference#generate-autoincrementing-integers-as-ids) function (which creates incrementing `@id` values) is not supported because `autoincrement()` does not work with the `ObjectID` type that the `_id` field has in MongoDB.
+
+
+
+### Cyclic references and referential actions
+
+If you have cyclic references in your models, either from self-relations or a cycle of relations between models, and you use [referential actions](/orm/prisma-schema/data-model/relations/referential-actions), you must set a referential action of `NoAction` to prevent an infinite loop of actions.
+
+See [Special rules for referential actions](/orm/prisma-schema/data-model/relations/referential-actions/special-rules-for-referential-actions) for more details.
+
+### Replica set configuration
+
+MongoDB only allows you to start a transaction on a replica set. Prisma uses transactions internally to avoid partial writes on nested queries. This means we inherit the requirement of needing a replica set configured.
+
+When you try to use Prisma's MongoDB connector on a deployment that has no replica set configured, Prisma shows the message `Error: Transactions are not supported by this deployment`. The full text of the error message is the following:
+
+```
+PrismaClientUnknownRequestError2 [PrismaClientUnknownRequestError]:
+Invalid `prisma.post.create()` invocation in
+/index.ts:9:21
+
+ 6 await prisma.$connect()
+ 7
+ 8 // Create the first post
+→ 9 await prisma.post.create(
+ Error in connector: Database error. error code: unknown, error message: Transactions are not supported by this deployment
+ at cb (/node_modules/@prisma/client/runtime/index.js:34804:17)
+ at processTicksAndRejections (internal/process/task_queues.js:97:5) {
+ clientVersion: '3.xx.0'
+}
+```
+
+To resolve this, we suggest you change your deployment to one with a replica set configured.
+
+One simple way for this is to use [MongoDB Atlas](https://www.mongodb.com/cloud/atlas) to launch a free instance that has replica set support out of the box.
+
+There's also an option to run the replica set locally with this guide: https://docs.mongodb.com/manual/tutorial/convert-standalone-to-replica-set
+
+## Type mapping between MongoDB and the Prisma schema
+
+The MongoDB connector maps the [scalar types](/orm/prisma-schema/data-model/models#scalar-fields) from the Prisma [data model](/orm/prisma-schema/data-model/models) to MongoDB's native column types as follows:
+
+> Alternatively, see [Prisma schema reference](/orm/reference/prisma-schema-reference#model-field-scalar-types) for type mappings organized by Prisma type.
+
+### Native type mapping from Prisma to MongoDB
+
+| Prisma | MongoDB |
+| ---------- | ---------------------------------------------------------------------- |
+| `String` | `string` |
+| `Boolean` | `bool` |
+| `Int` | `int` |
+| `BigInt` | `long` |
+| `Float` | `double` |
+| `Decimal` | [Currently unsupported](https://github.com/prisma/prisma/issues/12637) |
+| `DateTime` | `timestamp` |
+| `Bytes` | `binData` |
+| `Json` | |
+
+MongoDB types that are currently unsupported:
+
+- `Decimal128`
+- `Undefined`
+- `DBPointer`
+- `Null`
+- `Symbol`
+- `MinKey`
+- `MaxKey`
+- `Object`
+- `Javascript`
+- `JavascriptWithScope`
+- `Regex`
+
+### Mapping from MongoDB to Prisma types on Introspection
+
+When introspecting a MongoDB database, Prisma uses the relevant [scalar types](/orm/prisma-schema/data-model/models#scalar-fields). Some special types also get additional native type annotations:
+
+| MongoDB (Type \| Aliases) | Prisma | Supported | Native database type attribute | Notes |
+| ------------------------- | -------- | :-------: | :----------------------------- | :---- |
+| `objectId` | `String` | ✔️ | `@db.ObjectId` | |
+
+[Introspection](/orm/prisma-schema/introspection) adds native database types that are **not yet supported** as [`Unsupported`](/orm/reference/prisma-schema-reference#unsupported) fields:
+
+```prisma file=schema.prisma
+model Example {
+ id String @id @default(auto()) @map("_id") @db.ObjectId
+ name String
+ regex Unsupported("RegularExpression")
+}
+```
diff --git a/content/200-concepts/200-database-connectors/08-sql-server/020-sql-server-local.mdx b/content/200-orm/050-overview/500-databases/800-sql-server/020-sql-server-local.mdx
similarity index 98%
rename from content/200-concepts/200-database-connectors/08-sql-server/020-sql-server-local.mdx
rename to content/200-orm/050-overview/500-databases/800-sql-server/020-sql-server-local.mdx
index 464e1a3499..fd7c5ebe4c 100644
--- a/content/200-concepts/200-database-connectors/08-sql-server/020-sql-server-local.mdx
+++ b/content/200-orm/050-overview/500-databases/800-sql-server/020-sql-server-local.mdx
@@ -14,7 +14,7 @@ To run a Microsoft SQL Server locally on a Windows machine:
1. Use Windows Authentication to log in to Microsoft SQL Server Management Studio (expand the **Server Name** dropdown and click **<Browse for more...>** to find your database engine):
-
+
diff --git a/content/200-concepts/200-database-connectors/08-sql-server/030-sql-server-docker.mdx b/content/200-orm/050-overview/500-databases/800-sql-server/030-sql-server-docker.mdx
similarity index 100%
rename from content/200-concepts/200-database-connectors/08-sql-server/030-sql-server-docker.mdx
rename to content/200-orm/050-overview/500-databases/800-sql-server/030-sql-server-docker.mdx
diff --git a/content/200-concepts/200-database-connectors/08-sql-server/index.mdx b/content/200-orm/050-overview/500-databases/800-sql-server/index.mdx
similarity index 94%
rename from content/200-concepts/200-database-connectors/08-sql-server/index.mdx
rename to content/200-orm/050-overview/500-databases/800-sql-server/index.mdx
index 73057932fe..79dcac9272 100644
--- a/content/200-concepts/200-database-connectors/08-sql-server/index.mdx
+++ b/content/200-orm/050-overview/500-databases/800-sql-server/index.mdx
@@ -13,7 +13,7 @@ The Microsoft SQL Server data source connector connects Prisma to a [Microsoft S
## Example
-To connect to a Microsoft SQL Server database, you need to configure a [`datasource`](/concepts/components/prisma-schema/data-sources) block in your [Prisma schema file](/concepts/components/prisma-schema):
+To connect to a Microsoft SQL Server database, you need to configure a [`datasource`](/orm/prisma-schema/overview/data-sources) block in your [Prisma schema file](/orm/prisma-schema):
```prisma file=schema.prisma
datasource db {
@@ -25,7 +25,7 @@ datasource db {
The fields passed to the `datasource` block are:
- `provider`: Specifies the `sqlserver` data source connector.
-- `url`: Specifies the [connection URL](#connection-details) for the Microsoft SQL Server database. In this case, an [environment variable is used](/concepts/components/prisma-schema#accessing-environment-variables-from-the-schema) to provide the connection URL.
+- `url`: Specifies the [connection URL](#connection-details) for the Microsoft SQL Server database. In this case, an [environment variable is used](/orm/prisma-schema/overview#accessing-environment-variables-from-the-schema) to provide the connection URL.
## Connection details
@@ -84,7 +84,7 @@ sqlserver://mycomputer\sql2019;database=sample;integratedSecurity=true;trustServ
| | No - see Comments | | Password for SQL Server login _or_ Windows (Active Directory) username if `integratedSecurity` is set to `true` (Windows only). |
| `encrypt` | No | `true` | Configures whether to use TLS all the time, or only for the login procedure, possible values: `true` (use always), `false` (only for login credentials). |
| `integratedSecurity` | No | | Enables [Windows authentication (integrated security)](https://docs.microsoft.com/en-us/dotnet/framework/data/adonet/sql/authentication-in-sql-server), possible values: `true`, `false`, `yes`, `no`. If set to `true` or `yes` and `username` and `password` are present, login is performed through Windows Active Directory. If login details are not given via separate arguments, the current logged in Windows user is used to login to the server. |
-| `connectionLimit` | No | `num_cpus * 2 + 1` | Maximum size of the [connection pool](/concepts/components/prisma-client/working-with-prismaclient/connection-pool) |
+| `connectionLimit` | No | `num_cpus * 2 + 1` | Maximum size of the [connection pool](/orm/prisma-client/setup-and-configuration/databases-connections/connection-pool) |
| `connectTimeout` | No | `5` | Maximum number of seconds to wait for a new connection |
| `schema` | No | `dbo` | Added as a prefix to all the queries if schema name is not the default. |
| - `loginTimeout`
- `connectTimeout`
- `connectionTimeout`
| No | | Number of seconds to wait for login to succeed. |
@@ -97,11 +97,11 @@ sqlserver://mycomputer\sql2019;database=sample;integratedSecurity=true;trustServ
## Type mapping between Microsoft SQL Server to Prisma schema
-For type mappings organized by Prisma type, refer to the [Prisma schema reference](/reference/api-reference/prisma-schema-reference#model-field-scalar-types) documentation.
+For type mappings organized by Prisma type, refer to the [Prisma schema reference](/orm/reference/prisma-schema-reference#model-field-scalar-types) documentation.
## Supported versions
-See [Supported databases](/reference/database-reference/supported-databases).
+See [Supported databases](/orm/reference/supported-databases).
## Limitations and known issues
@@ -115,9 +115,9 @@ SQL Server does not have an equivalent to the PostgreSQL `SET search_path` comma
#### Cyclic references
-Circular references can occur between models when each model references another, creating a closed loop. When using a Microsoft SQL Server database, Prisma will show a validation error if the [referential action](/concepts/components/prisma-schema/relations/referential-actions) on a relation is set to something other than [`NoAction`](/concepts/components/prisma-schema/relations/referential-actions#noaction).
+Circular references can occur between models when each model references another, creating a closed loop. When using a Microsoft SQL Server database, Prisma will show a validation error if the [referential action](/orm/prisma-schema/data-model/relations/referential-actions) on a relation is set to something other than [`NoAction`](/orm/prisma-schema/data-model/relations/referential-actions#noaction).
-See [Special rules for referential actions in SQL Server](/concepts/components/prisma-schema/relations/referential-actions/special-rules-for-referential-actions) for more information.
+See [Special rules for referential actions in SQL Server](/orm/prisma-schema/data-model/relations/referential-actions/special-rules-for-referential-actions) for more information.
#### Destructive changes
diff --git a/content/300-guides/050-database/850-planetscale.mdx b/content/200-orm/050-overview/500-databases/850-planetscale.mdx
similarity index 84%
rename from content/300-guides/050-database/850-planetscale.mdx
rename to content/200-orm/050-overview/500-databases/850-planetscale.mdx
index 2bbecfa038..720823470a 100644
--- a/content/300-guides/050-database/850-planetscale.mdx
+++ b/content/200-orm/050-overview/500-databases/850-planetscale.mdx
@@ -1,7 +1,7 @@
---
-title: 'Using Prisma with PlanetScale'
-metaTitle: 'Using Prisma with PlanetScale'
-metaDescription: 'Guide to using Prisma with PlanetScale'
+title: 'PlanetScale'
+metaTitle: 'PlanetScale'
+metaDescription: 'Guide to PlanetScale'
tocDepth: 3
toc: true
---
@@ -18,21 +18,19 @@ This document discusses the concepts behind using Prisma and PlanetScale, explai
PlanetScale uses the [Vitess](https://vitess.io/) database clustering system to provide a MySQL-compatible database platform. Features include:
-- **Enterprise scalability.** PlanetScale provides a highly available production database cluster that supports scaling across multiple database servers. This is particularly useful in a serverless context, as it avoids the problem of having to [manage connection limits](/guides/performance-and-optimization/connection-management#serverless-environments-faas).
-
+- **Enterprise scalability.** PlanetScale provides a highly available production database cluster that supports scaling across multiple database servers. This is particularly useful in a serverless context, as it avoids the problem of having to [manage connection limits](/orm/prisma-client/setup-and-configuration/databases-connections#serverless-environments-faas).
- **Database branches.** PlanetScale allows you to create [branches of your database schema](https://planetscale.com/docs/concepts/branching), so that you can test changes on a development branch before applying them to your production database.
-
- **Support for [non-blocking schema changes](https://planetscale.com/docs/concepts/nonblocking-schema-changes).** PlanetScale provides a workflow that allows users to update database schemas without locking the database or causing downtime.
## Commonalities with other database providers
Many aspects of using Prisma with PlanetScale are just like using Prisma with any other relational database. You can still:
-- model your database with the [Prisma Schema Language](/concepts/components/prisma-schema)
-- use Prisma's existing [`mysql` database connector](/concepts/database-connectors/mysql) in your schema, along with the [connection string PlanetScale provides you](https://planetscale.com/docs/concepts/connection-strings)
-- use [Introspection](/concepts/components/introspection) for existing projects if you already have a database schema in PlanetScale
-- use [`db push`](/concepts/components/prisma-migrate/db-push) to push changes in your schema to the database
-- use [Prisma Client](/concepts/components/prisma-client) in your application to talk to the database server at PlanetScale
+- model your database with the [Prisma Schema Language](/orm/prisma-schema)
+- use Prisma's existing [`mysql` database connector](/orm/overview/databases/mysql) in your schema, along with the [connection string PlanetScale provides you](https://planetscale.com/docs/concepts/connection-strings)
+- use [Introspection](/orm/prisma-schema/introspection) for existing projects if you already have a database schema in PlanetScale
+- use [`db push`](/orm/prisma-migrate/workflows/prototyping-your-schema) to push changes in your schema to the database
+- use [Prisma Client](/orm/prisma-client) in your application to talk to the database server at PlanetScale
## Differences to consider
@@ -41,11 +39,11 @@ PlanetScale's branching model and design for scalability means that there are al
- **Branching and deploy requests.** PlanetScale provides two types of database branches: _development branches_, which allow you to test out schema changes, and _production branches_, which are protected from direct schema changes. Instead, changes must be first created on a development branch and then deployed to production using a deploy request. Production branches are highly available and include automated daily backups. To learn more, see [How to use branches and deploy requests](#how-to-use-branches-and-deploy-requests).
- **Referential actions and integrity.** To support scaling across multiple database servers, PlanetScale [does not allow the use of foreign key constraints](https://planetscale.com/docs/learn/operating-without-foreign-key-constraints), which are normally used in relational databases to enforce relationships between data in different tables, and asks users to handle this manually in their applications.
- With Prisma you can maintain these relationships in your data and allow the use of [referential actions](/concepts/components/prisma-schema/relations/referential-actions) by using Prisma's ability to [emulate relations in Prisma Client](/concepts/components/prisma-schema/relations/relation-mode#emulate-relations-in-prisma-with-the-prisma-relation-mode) with the `prisma` relation mode. For more information, see [How to emulate relations in Prisma Client](#how-to-emulate-relations-in-prisma-client).
+ With Prisma you can maintain these relationships in your data and allow the use of [referential actions](/orm/prisma-schema/data-model/relations/referential-actions) by using Prisma's ability to [emulate relations in Prisma Client](/orm/prisma-schema/data-model/relations/relation-mode#emulate-relations-in-prisma-with-the-prisma-relation-mode) with the `prisma` relation mode. For more information, see [How to emulate relations in Prisma Client](#how-to-emulate-relations-in-prisma-client).
- **Creating indexes on foreign keys.** When emulating relations in Prisma, you will need to create indexes on foreign keys. In a standard MySQL database, if a table has a column with a foreign key constraint, an index is automatically created on that column. Because PlanetScale does not support foreign keys, these indexes are [currently](https://github.com/prisma/prisma/issues/10611) not created when Prisma Client emulates relations, which can lead to issues with queries not being well optimised. To avoid this, you can create indexes in Prisma. For more information, see [How to create indexes on foreign keys](#how-to-create-indexes-on-foreign-keys).
-- **Making schema changes with `db push`.** When you merge a development branch into your production branch, PlanetScale will automatically compare the two schemas and generate its own schema diff. This means that Prisma's [`prisma migrate`](/concepts/components/prisma-migrate) workflow, which generates its own history of migration files, is not a natural fit when working with PlanetScale. These migration files may not reflect the actual schema changes run by PlanetScale when the branch is merged.
+- **Making schema changes with `db push`.** When you merge a development branch into your production branch, PlanetScale will automatically compare the two schemas and generate its own schema diff. This means that Prisma's [`prisma migrate`](/orm/prisma-migrate) workflow, which generates its own history of migration files, is not a natural fit when working with PlanetScale. These migration files may not reflect the actual schema changes run by PlanetScale when the branch is merged.
@@ -63,11 +61,11 @@ When connecting to PlanetScale with Prisma, you will need to use the correct con
Every PlanetScale database is created with a branch called `main`, which is initially a development branch that you can use to test schema changes on. Once you are happy with the changes you make there, you can [promote it](https://planetscale.com/docs/concepts/branching#promote-a-branch-to-production) to become a production branch. Note that you can only push new changes to a development branch, so further changes will need to be created on a separate development branch and then later deployed to production using a [deploy request](https://planetscale.com/docs/concepts/branching#2.-create-a-deploy-request).
-If you try to push to a production branch, you will get the [error message](/reference/api-reference/error-reference#p3022) `Direct execution of DDL (Data Definition Language) SQL statements is disabled on this database.`
+If you try to push to a production branch, you will get the [error message](/orm/reference/error-reference#p3022) `Direct execution of DDL (Data Definition Language) SQL statements is disabled on this database.`
## How to emulate relations in Prisma Client
-PlanetScale does not allow foreign keys in its database schema. By default, Prisma uses foreign keys in the underlying database to enforce relations between fields in your Prisma schema. In Prisma versions 3.1.1 and later, you can [emulate relations in Prisma Client with the `prisma` relation mode](/concepts/components/prisma-schema/relations/relation-mode#emulate-relations-in-prisma-with-the-prisma-relation-mode), which avoids the need for foreign keys in the database.
+PlanetScale does not allow foreign keys in its database schema. By default, Prisma uses foreign keys in the underlying database to enforce relations between fields in your Prisma schema. In Prisma versions 3.1.1 and later, you can [emulate relations in Prisma Client with the `prisma` relation mode](/orm/prisma-schema/data-model/relations/relation-mode#emulate-relations-in-prisma-with-the-prisma-relation-mode), which avoids the need for foreign keys in the database.
To enable emulation of relations in Prisma Client, set the `relationMode` field to `"prisma"` in the `datasource` block:
@@ -85,7 +83,7 @@ The ability to set the relation mode was introduced as part of the `referentialI
-If you use relations in your Prisma schema with the default `"foreignKeys"` option for the `referentialIntegrity` field, PlanetScale will error when Prisma tries to create foreign keys. In versions 2.27.0 and later, Prisma will output the [P3021 error message](/reference/api-reference/error-reference#p3021).
+If you use relations in your Prisma schema with the default `"foreignKeys"` option for the `referentialIntegrity` field, PlanetScale will error when Prisma tries to create foreign keys. In versions 2.27.0 and later, Prisma will output the [P3021 error message](/orm/reference/error-reference#p3021).
## How to create indexes on foreign keys
@@ -110,7 +108,7 @@ model Comment {
The `postId` field in the `Comment` model refers to the corresponding `id` field in the `Post` model. However this is not implemented as a foreign key in PlanetScale, so the column doesn't have an automatic index. This means that some queries may not be well optimised. For example, if you query for all comments with a certain post `id`, PlanetScale may have to do a full table lookup. This could be slow, and also expensive because PlanetScale's billing model charges for the number of rows read.
-To avoid this, you can define an index on the `postId` field using [Prisma's `@@index` argument](/reference/api-reference/prisma-schema-reference#index):
+To avoid this, you can define an index on the `postId` field using [Prisma's `@@index` argument](/orm/reference/prisma-schema-reference#index):
```prisma file=schema.prisma highlight=15;add
model Post {
@@ -133,17 +131,17 @@ model Comment {
You can then add this change to your schema [using `db push`](#how-to-make-schema-changes-with-db-push).
-In Prisma versions 4.7.0 and later, Prisma warns you if you have a relation with no index on the relation scalar field. For more information, see [Index validation](/concepts/components/prisma-schema/relations/relation-mode#index-validation).
+In Prisma versions 4.7.0 and later, Prisma warns you if you have a relation with no index on the relation scalar field. For more information, see [Index validation](/orm/prisma-schema/data-model/relations/relation-mode#index-validation).
-One issue to be aware of is that [implicit many-to-many relations](/concepts/components/prisma-schema/relations/many-to-many-relations#implicit-many-to-many-relations) cannot have an index added in this way. If query speed or cost is an issue, you may instead want to use an [explicit many-to-many relation](/concepts/components/prisma-schema/relations/many-to-many-relations#explicit-many-to-many-relations) in this case.
+One issue to be aware of is that [implicit many-to-many relations](/orm/prisma-schema/data-model/relations/many-to-many-relations#implicit-many-to-many-relations) cannot have an index added in this way. If query speed or cost is an issue, you may instead want to use an [explicit many-to-many relation](/orm/prisma-schema/data-model/relations/many-to-many-relations#explicit-many-to-many-relations) in this case.
## How to make schema changes with db push
-To use `db push` with PlanetScale, you will first need to [enable emulation of relations in Prisma Client](#how-to-emulate-relations-in-prisma-client). Pushing to your branch without referential emulation enabled will give the [error message](/reference/api-reference/error-reference#p3021) `Foreign keys cannot be created on this database.`
+To use `db push` with PlanetScale, you will first need to [enable emulation of relations in Prisma Client](#how-to-emulate-relations-in-prisma-client). Pushing to your branch without referential emulation enabled will give the [error message](/orm/reference/error-reference#p3021) `Foreign keys cannot be created on this database.`
As an example, let's say you decide to decide to add a new `excerpt` field to the blog post schema above. You will first need to [create a new development branch and connect to it](#how-to-use-branches-and-deploy-requests).
diff --git a/content/200-concepts/200-database-connectors/08-cockroachdb.mdx b/content/200-orm/050-overview/500-databases/860-cockroachdb.mdx
similarity index 61%
rename from content/200-concepts/200-database-connectors/08-cockroachdb.mdx
rename to content/200-orm/050-overview/500-databases/860-cockroachdb.mdx
index dee427f3aa..eda18fc474 100644
--- a/content/200-concepts/200-database-connectors/08-cockroachdb.mdx
+++ b/content/200-orm/050-overview/500-databases/860-cockroachdb.mdx
@@ -1,25 +1,101 @@
---
title: 'CockroachDB'
-metaTitle: 'CockroachDB database connector (Reference)'
-metaDescription: 'This page explains how Prisma can connect to a CockroachDB database using the CockroachDB database connector.'
+metaTitle: 'CockroachDB'
+metaDescription: 'Guide to CockroachDB'
tocDepth: 3
+toc: true
---
-The CockroachDB data source connector connects Prisma to a [CockroachDB](https://www.cockroachlabs.com/) database server.
+This guide discusses the concepts behind using Prisma and CockroachDB, explains the commonalities and differences between CockroachDB and other database providers, and leads you through the process for configuring your application to integrate with CockroachDB.
+
+
-The CockroachDB connector is generally available in versions `3.14.0` and later. It was first added as a [Preview feature](/concepts/components/preview-features) in version [`3.9.0`](https://github.com/prisma/prisma/releases/tag/3.9.0) with support for Introspection, and Prisma Migrate support was added in [`3.11.0`](https://github.com/prisma/prisma/releases/tag/3.11.0).
+The CockroachDB connector is generally available in versions `3.14.0` and later. It was first added as a [Preview feature](/orm/reference/preview-features) in version [`3.9.0`](https://github.com/prisma/prisma/releases/tag/3.9.0) with support for Introspection, and Prisma Migrate support was added in [`3.11.0`](https://github.com/prisma/prisma/releases/tag/3.11.0).
-
+## What is CockroachDB?
+
+CockroachDB is a distributed database that is designed for scalability and high availability. Features include:
+
+- **Built-in scaling:** CockroachDB comes with automated replication, failover and repair capabilities to allow easy horizontal scaling of your application
+- **Consistent transactions:** CockroachDB is a relational database that supports consistent transactions that maintain data integrity
+- **Compatibility with PostgreSQL:** CockroachDB is compatible with PostgreSQL, allowing interoperability with a large ecosystem of existing products
+
+## Commonalities with other database providers
+
+CockroachDB is largely compatible with PostgreSQL, and can mostly be used with Prisma in the same way. You can still:
+
+- model your database with the [Prisma Schema Language](/orm/prisma-schema)
+- connect to your database, using Prisma's [`cockroachdb` database connector](/orm/overview/databases/cockroachdb)
+- use [Introspection](/orm/prisma-schema/introspection) for existing projects if you already have a CockroachDB database
+- use [Prisma Migrate](/orm/prisma-migrate) to migrate your database schema to a new version
+- use [Prisma Client](/orm/prisma-client) in your application to query your database in a type safe way based on your Prisma Schema
+
+## Differences to consider
+
+There are some CockroachDB-specific differences to be aware of when working with Prisma's `cockroachdb` connector:
+
+- **Cockroach-specific native types:** Prisma's `cockroachdb` database connector provides support for CockroachDB's native data types. To learn more, see [How to use CockroachDB's native types](#how-to-use-cockroachdbs-native-types).
+
+- **Creating database keys:** Prisma allows you to generate a unique identifier for each record using the [`autoincrement()`](/orm/reference/prisma-schema-reference#autoincrement) function. For more information, see [How to use database keys with CockroachDB](#how-to-use-database-keys-with-cockroachdb).
+
+## How to use Prisma with CockroachDB
+
+This section provides more details on how to use CockroachDB-specific features.
+
+### How to use CockroachDB's native types
+
+CockroachDB has its own set of native [data types](https://www.cockroachlabs.com/docs/stable/data-types.html) which are supported in Prisma. For example, CockroachDB uses the `STRING` data type instead of PostgreSQL's `VARCHAR`.
+
+As a demonstration of this, say you create a `User` table in your CockroachDB database using the following SQL command:
+
+```sql
+CREATE TABLE public."Post" (
+ "id" INT8 NOT NULL,
+ "title" VARCHAR(200) NOT NULL,
+ CONSTRAINT "Post_pkey" PRIMARY KEY ("id" ASC),
+ FAMILY "primary" ("id", "title")
+);
+```
+
+After introspecting your database with `npx prisma db pull`, you will have a new `Post` model in your `schema.prisma` file:
+
+```prisma file=schema.prisma
+model Post {
+ id BigInt @id
+ title String @db.String(200)
+}
+```
+
+Notice that the `title` field has been annotated with `@db.String(200)` — this differs from PostgreSQL where the annotation would be `@db.VarChar(200)`.
+
+For a full list of type mappings, see our [connector documentation](/orm/overview/databases/cockroachdb#type-mapping-between-cockroachdb-and-the-prisma-schema).
+
+### How to use database keys with CockroachDB
+
+When generating unique identifiers for records in a distributed database like CockroachDB, it is best to avoid using sequential IDs – for more information on this, see CockroachDB's [blog post on choosing index keys](https://cockroachlabs.com/blog/how-to-choose-db-index-keys).
+
+Instead, Prisma provides the [`autoincrement()`](/orm/reference/prisma-schema-reference#autoincrement) attribute function, which uses CockroachDB's [`unique_rowid()` function](https://www.cockroachlabs.com/docs/stable/serial.html) for generating unique identifiers. For example, the following `User` model has an `id` primary key, generated using the `autoincrement()` function:
+
+```prisma file=schema.prisma
+model User {
+ id BigInt @id @default(autoincrement())
+ name String
+}
+```
+
+For compatibility with existing databases, you may sometimes still need to generate a fixed sequence of integer key values. In these cases, you can use Prisma's inbuilt [`sequence()`](/orm/reference/prisma-schema-reference#sequence) function for CockroachDB. For a list of available options for the `sequence()` function, see our [reference documentation](/orm/reference/prisma-schema-reference#sequence).
+
+For more information on generating database keys, see CockroachDB's [Primary key best practices](https://www.cockroachlabs.com/docs/v21.2/schema-design-table#primary-key-best-practices) guide.
## Example
-To connect to a CockroachDB database server, you need to configure a [`datasource`](/concepts/components/prisma-schema/data-sources) block in your [Prisma schema file](/concepts/components/prisma-schema):
+To connect to a CockroachDB database server, you need to configure a [`datasource`](/orm/prisma-schema/overview/data-sources) block in your [Prisma schema file](/orm/prisma-schema):
```prisma file=schema.prisma
datasource db {
@@ -31,7 +107,7 @@ datasource db {
The fields passed to the `datasource` block are:
- `provider`: Specifies the `cockroachdb` data source connector.
-- `url`: Specifies the [connection URL](#connection-details) for the CockroachDB database server. In this case, an [environment variable is used](/concepts/components/prisma-schema#accessing-environment-variables-from-the-schema) to provide the connection URL.
+- `url`: Specifies the [connection URL](#connection-details) for the CockroachDB database server. In this case, an [environment variable is used](/orm/prisma-schema/overview#accessing-environment-variables-from-the-schema) to provide the connection URL.
@@ -41,7 +117,7 @@ While `cockroachdb` and `postgresql` connectors are similar, it is mandatory to
## Connection details
-CockroachDB uses the PostgreSQL format for its connection URL. See the [PostgreSQL connector documentation](/concepts/database-connectors/postgresql#connection-details) for details of this format, and the optional arguments it takes.
+CockroachDB uses the PostgreSQL format for its connection URL. See the [PostgreSQL connector documentation](/orm/overview/databases/postgresql#connection-details) for details of this format, and the optional arguments it takes.
## Differences between CockroachDB and PostgreSQL
@@ -55,7 +131,7 @@ The following table lists differences between CockroachDB and PostgreSQL:
## Type mapping limitations in CockroachDB
-The CockroachDB connector maps the [scalar types](/concepts/components/prisma-schema/data-model#scalar-fields) from the Prisma [data model](/concepts/components/prisma-schema/data-model) to native column types. These native types are mostly the same as for PostgreSQL — see the [Native type mapping from Prisma to CockroachDB](#native-type-mapping-from-prisma-to-cockroachdb) for details. However, there are some limitations:
+The CockroachDB connector maps the [scalar types](/orm/prisma-schema/data-model/models#scalar-fields) from the Prisma [data model](/orm/prisma-schema/data-model/models) to native column types. These native types are mostly the same as for PostgreSQL — see the [Native type mapping from Prisma to CockroachDB](#native-type-mapping-from-prisma-to-cockroachdb) for details. However, there are some limitations:
| CockroachDB (Type \| Aliases) | Prisma | Supported | Native database type attribute | Notes |
| ----------------------------- | --------- | :-------: | :----------------------------- | :------------------------------------------------------------------------------------------------------------------------- |
@@ -67,21 +143,21 @@ The CockroachDB connector maps the [scalar types](/concepts/components/prisma-sc
The following table lists any other current known limitations of CockroachDB compared to PostgreSQL:
-| Issue | Area | Notes |
-| ------------------------------------------------------------------------------------------------ | ------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| Primary keys are named `primary` instead of `TABLE_pkey`, the Prisma default. | Introspection | This means that they are introspected as `@id(map: "primary")`. This will be [fixed in CockroachDB 22.1](https://github.com/cockroachdb/cockroach/pull/70604). |
-| Foreign keys are named `fk_COLUMN_ref_TABLE` instead of `TABLE_COLUMN_fkey`, the Prisma default. | Introspection | This means that they are introspected as `@relation([...], map: "fk_COLUMN_ref_TABLE")`. This will be [fixed in CockroachDB 22.1](https://github.com/cockroachdb/cockroach/pull/70658) |
-| Index types `Hash`, `Gist`, `SpGist` or `Brin` are not supported. | Schema | In PostgreSQL, Prisma allows [configuration of indexes](/concepts/components/prisma-schema/indexes#configuring-the-access-type-of-indexes-with-type-postgresql) to use the different index access method. CockroachDB only currently supports `BTree` and `Gin`. |
-| Pushing to `Enum` types not supported | Client | Pushing to `Enum` types (e.g. `data: { enum { push: "A" }, }`) is currently [not supported in CockroachDB](https://github.com/cockroachdb/cockroach/issues/71388) |
-| Searching on `String` fields without a full text index not supported | Client | Searching on `String` fields without a full text index (e.g. `where: { text: { search: "cat & dog", }, },`) is currently [not supported in CockroachDB](https://github.com/cockroachdb/cockroach/issues/7821) |
-| Integer division not supported | Client | Integer division (e.g. `data: { int: { divide: 10, }, }`) is currently [not supported in CockroachDB](https://github.com/cockroachdb/cockroach/issues/41448) |
-| Limited filtering on `Json` fields | Client | Currently CockroachDB [only supports](https://github.com/cockroachdb/cockroach/issues/49144) `equals` and `not` filtering on `Json` fields |
+| Issue | Area | Notes |
+| ------------------------------------------------------------------------------------------------ | ------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Primary keys are named `primary` instead of `TABLE_pkey`, the Prisma default. | Introspection | This means that they are introspected as `@id(map: "primary")`. This will be [fixed in CockroachDB 22.1](https://github.com/cockroachdb/cockroach/pull/70604). |
+| Foreign keys are named `fk_COLUMN_ref_TABLE` instead of `TABLE_COLUMN_fkey`, the Prisma default. | Introspection | This means that they are introspected as `@relation([...], map: "fk_COLUMN_ref_TABLE")`. This will be [fixed in CockroachDB 22.1](https://github.com/cockroachdb/cockroach/pull/70658) |
+| Index types `Hash`, `Gist`, `SpGist` or `Brin` are not supported. | Schema | In PostgreSQL, Prisma allows [configuration of indexes](/orm/prisma-schema/data-model/indexes#configuring-the-access-type-of-indexes-with-type-postgresql) to use the different index access method. CockroachDB only currently supports `BTree` and `Gin`. |
+| Pushing to `Enum` types not supported | Client | Pushing to `Enum` types (e.g. `data: { enum { push: "A" }, }`) is currently [not supported in CockroachDB](https://github.com/cockroachdb/cockroach/issues/71388) |
+| Searching on `String` fields without a full text index not supported | Client | Searching on `String` fields without a full text index (e.g. `where: { text: { search: "cat & dog", }, },`) is currently [not supported in CockroachDB](https://github.com/cockroachdb/cockroach/issues/7821) |
+| Integer division not supported | Client | Integer division (e.g. `data: { int: { divide: 10, }, }`) is currently [not supported in CockroachDB](https://github.com/cockroachdb/cockroach/issues/41448) |
+| Limited filtering on `Json` fields | Client | Currently CockroachDB [only supports](https://github.com/cockroachdb/cockroach/issues/49144) `equals` and `not` filtering on `Json` fields |
## Type mapping between CockroachDB and the Prisma schema
-The CockroachDB connector maps the [scalar types](/concepts/components/prisma-schema/data-model#scalar-fields) from the Prisma [data model](/concepts/components/prisma-schema/data-model) as follows to native column types:
+The CockroachDB connector maps the [scalar types](/orm/prisma-schema/data-model/models#scalar-fields) from the Prisma [data model](/orm/prisma-schema/data-model/models) as follows to native column types:
-> Alternatively, see the [Prisma schema reference](/reference/api-reference/prisma-schema-reference#model-field-scalar-types) for type mappings organized by Prisma type.
+> Alternatively, see the [Prisma schema reference](/orm/reference/prisma-schema-reference#model-field-scalar-types) for type mappings organized by Prisma type.
### Native type mapping from Prisma to CockroachDB
@@ -127,7 +203,7 @@ When introspecting a CockroachDB database, the database types are mapped to Pris
| `JSONB` \| `JSON` | `Json` | ✔️ | `@db.JsonB` | |
| Array types | `[]` | ✔️ | | |
-[Introspection](/concepts/components/introspection) adds native database types that are **not yet supported** as [`Unsupported`](/reference/api-reference/prisma-schema-reference#unsupported) fields:
+[Introspection](/orm/prisma-schema/introspection) adds native database types that are **not yet supported** as [`Unsupported`](/orm/reference/prisma-schema-reference#unsupported) fields:
```prisma file=schema.prisma
model Device {
@@ -135,3 +211,14 @@ model Device {
interval Unsupported("INTERVAL")
}
```
+
+## More on using CockroachDB with Prisma
+
+The fastest way to start using CockroachDB with Prisma is to refer to our Getting Started documentation:
+
+- [Start from scratch](/getting-started/setup-prisma/start-from-scratch/relational-databases-typescript-cockroachdb)
+- [Add to existing project](/getting-started/setup-prisma/add-to-existing-project/relational-databases-typescript-cockroachdb)
+
+These tutorials will take you through the process of connecting to CockroachDB, migrating your schema, and using Prisma Client.
+
+Further reference information is available in the [CockroachDB connector documentation](/orm/overview/databases/cockroachdb).
diff --git a/content/300-guides/050-database/880-supabase.mdx b/content/200-orm/050-overview/500-databases/880-supabase.mdx
similarity index 78%
rename from content/300-guides/050-database/880-supabase.mdx
rename to content/200-orm/050-overview/500-databases/880-supabase.mdx
index 75a6b5a0c0..4c794cd5fa 100644
--- a/content/300-guides/050-database/880-supabase.mdx
+++ b/content/200-orm/050-overview/500-databases/880-supabase.mdx
@@ -1,7 +1,7 @@
---
-title: 'Using Prisma with Supabase'
-metaTitle: 'Using Prisma with Supabase'
-metaDescription: 'Guide to using Prisma with Supabase'
+title: 'Supabase'
+metaTitle: 'Supabase'
+metaDescription: 'Guide to Supabase'
tocDepth: 2
toc: true
---
@@ -22,11 +22,11 @@ To learn more about Supabase, you can check out their architecture [here](https:
Many aspects of using Prisma with Supabase are just like using Prisma with any other relational database. You can still:
-- model your database with the [Prisma Schema Language](/concepts/components/prisma-schema)
-- use Prisma's existing [`postgresql` database connector](/concepts/database-connectors/postgresql) in your schema, along with the [connection string Supabase provides you](https://supabase.com/docs/guides/database/connecting-to-postgres#finding-your-connection-string)
-- use [Introspection](/concepts/components/introspection) for existing projects if you already have a database schema in Supabase
-- use [`db push`](/concepts/components/prisma-migrate/db-push) to push changes in your schema to Supabase
-- use [Prisma Client](/concepts/components/prisma-client) in your application to talk to the database server at Supabase
+- model your database with the [Prisma Schema Language](/orm/prisma-schema)
+- use Prisma's existing [`postgresql` database connector](/orm/overview/databases/postgresql) in your schema, along with the [connection string Supabase provides you](https://supabase.com/docs/guides/database/connecting-to-postgres#finding-your-connection-string)
+- use [Introspection](/orm/prisma-schema/introspection) for existing projects if you already have a database schema in Supabase
+- use [`db push`](/orm/prisma-migrate/workflows/prototyping-your-schema) to push changes in your schema to Supabase
+- use [Prisma Client](/orm/prisma-client) in your application to talk to the database server at Supabase
## Specific considerations
@@ -58,7 +58,7 @@ datasource db {
}
```
-More information about the `directUrl` field can be found [here](/reference/api-reference/prisma-schema-reference#fields).
+More information about the `directUrl` field can be found [here](/orm/reference/prisma-schema-reference#fields).
diff --git a/content/300-guides/050-database/890-neon.mdx b/content/200-orm/050-overview/500-databases/890-neon.mdx
similarity index 81%
rename from content/300-guides/050-database/890-neon.mdx
rename to content/200-orm/050-overview/500-databases/890-neon.mdx
index 0dfc244da5..9f53f12d9c 100644
--- a/content/300-guides/050-database/890-neon.mdx
+++ b/content/200-orm/050-overview/500-databases/890-neon.mdx
@@ -1,7 +1,7 @@
---
-title: 'Using Prisma with Neon'
-metaTitle: 'Using Prisma with Neon'
-metaDescription: 'Guide to using Prisma with Neon'
+title: 'Neon'
+metaTitle: 'Neon'
+metaDescription: 'Guide to Neon'
tocDepth: 2
toc: true
---
@@ -32,12 +32,12 @@ Learn more about Neon [here](https://neon.tech/docs).
Many aspects of using Prisma with Neon are just like using Prisma with any other PostgreSQL database. You can:
-- model your database with the [Prisma Schema Language](/concepts/components/prisma-schema)
-- use Prisma's [`postgresql` database connector](/concepts/database-connectors/postgresql) in your schema, along with the [connection string Neon provides you](https://neon.tech/docs/connect/connect-from-any-app)
-- use [Introspection](/concepts/components/introspection) for existing projects if you already have a database schema on Neon
-- use [`prisma migrate dev`](/concepts/components/prisma-migrate/migrate-development-production) to track schema migrations in your Neon database
-- use [`prisma db push`](/concepts/components/prisma-migrate/db-push) to push changes in your schema to Neon
-- use [Prisma Client](/concepts/components/prisma-client) in your application to communicate with the database hosted by Neon
+- model your database with the [Prisma Schema Language](/orm/prisma-schema)
+- use Prisma's [`postgresql` database connector](/orm/overview/databases/postgresql) in your schema, along with the [connection string Neon provides you](https://neon.tech/docs/connect/connect-from-any-app)
+- use [Introspection](/orm/prisma-schema/introspection) for existing projects if you already have a database schema on Neon
+- use [`prisma migrate dev`](/orm/prisma-migrate/workflows/development-and-production) to track schema migrations in your Neon database
+- use [`prisma db push`](/orm/prisma-migrate/workflows/prototyping-your-schema) to push changes in your schema to Neon
+- use [Prisma Client](/orm/prisma-client) in your application to communicate with the database hosted by Neon
## Differences to consider
@@ -76,7 +76,7 @@ datasource db {
}
```
-More information about the `directUrl` field can be found [here](/reference/api-reference/prisma-schema-reference#fields).
+More information about the `directUrl` field can be found [here](/orm/reference/prisma-schema-reference#fields).
@@ -109,7 +109,7 @@ A `connect_timeout` setting of 0 means no timeout.
-Another possible cause of connection timeouts is [Prisma's connection pool](https://www.prisma.io/docs/concepts/components/prisma-client/working-with-prismaclient/), which has a default timeout of 10 seconds. This is typically enough time for Neon, but if you are still experiencing connection timeouts, you can try increasing this limit (in addition to the `connect_timeout` setting described above) by setting the `pool_timeout` parameter to a higher value. For example:
+Another possible cause of connection timeouts is Prisma's [connection pool](/orm/prisma-client/setup-and-configuration/databases-connections/connection-pool), which has a default timeout of 10 seconds. This is typically enough time for Neon, but if you are still experiencing connection timeouts, you can try increasing this limit (in addition to the `connect_timeout` setting described above) by setting the `pool_timeout` parameter to a higher value. For example:
```text wrap
DATABASE_URL=postgres://daniel:@ep-mute-rain-952417.us-east-2.aws.neon.tech/neondb?connect_timeout=15&pool_timeout=15
@@ -119,7 +119,7 @@ DATABASE_URL=postgres://daniel:@ep-mute-rain-952417.us-east-2.aws.neon
The [Neon serverless driver](https://github.com/neondatabase/serverless) is a low-latency Postgres driver for JavaScript and TypeScript that allows you to query data from serverless and edge environments over HTTP or WebSockets in place of TCP.
-You can use Prisma along with the Neon serverless driver using a [driver adapter](/concepts/components/database-drivers#driver-adapters) . A driver adapter allows you to use a different database driver from the default Prisma provides to communicate with your database.
+You can use Prisma along with the Neon serverless driver using a [driver adapter](/orm/overview/databases/database-drivers#driver-adapters) . A driver adapter allows you to use a different database driver from the default Prisma provides to communicate with your database.
diff --git a/content/300-guides/050-database/900-turso.mdx b/content/200-orm/050-overview/500-databases/900-turso.mdx
similarity index 88%
rename from content/300-guides/050-database/900-turso.mdx
rename to content/200-orm/050-overview/500-databases/900-turso.mdx
index 8c14deec49..9b7527a6cd 100644
--- a/content/300-guides/050-database/900-turso.mdx
+++ b/content/200-orm/050-overview/500-databases/900-turso.mdx
@@ -1,7 +1,7 @@
---
-title: 'Using Prisma with Turso'
-metaTitle: 'Using Prisma with Turso (Early Access)'
-metaDescription: 'Guide to using Prisma with Turso'
+title: 'Turso'
+metaTitle: 'Turso (Early Access)'
+metaDescription: 'Guide to Turso'
tocDepth: 3
---
@@ -9,7 +9,7 @@ tocDepth: 3
This guide discusses the concepts behind using Prisma and Turso, explains the commonalities and differences between Turso and other database providers, and leads you through the process for configuring your application to integrate with Turso.
-Prisma support for Turso is currently in [Early Access](/about/prisma/releases#early-access). We would appreciate your feedback in this [GitHub discussion](https://github.com/prisma/prisma/discussions/21345).
+Prisma support for Turso is currently in [Early Access](/orm/more/releases#early-access). We would appreciate your feedback in this [GitHub discussion](https://github.com/prisma/prisma/discussions/21345).
@@ -25,7 +25,7 @@ Prisma support for Turso is currently in [Early Access](/about/prisma/releases#e
-Support for Turso is available in [Early Access](/about/prisma/releases#early-access) from Prisma versions 5.4.2 and later.
+Support for Turso is available in [Early Access](/orm/more/releases#early-access) from Prisma versions 5.4.2 and later.
@@ -43,16 +43,16 @@ libSQL is 100% compatible with SQLite. libSQL extends SQLite and adds the follow
Many aspects of using Prisma with Turso are just like using Prisma with any other relational database. You can still:
-- model your database with the [Prisma Schema Language](/concepts/components/prisma-schema)
-- use Prisma's existing [`sqlite` database connector](/concepts/database-connectors/sqlite) in your schema
-- use [Prisma Client](/concepts/components/prisma-client) in your application to talk to the database server at Turso
+- model your database with the [Prisma Schema Language](/orm/prisma-schema)
+- use Prisma's existing [`sqlite` database connector](/orm/overview/databases/sqlite) in your schema
+- use [Prisma Client](/orm/prisma-client) in your application to talk to the database server at Turso
## Differences to consider
There are a number of differences between Turso and SQLite to consider. You should be aware of the following when deciding to use Turso and Prisma:
- **Remote and embedded SQLite databases**. libSQL uses HTTP to connect to the remote SQLite database. libSQL also supports remote database replicas and embedded replicas. Embedded replicas enable you to replicate your primary database inside your application.
-- **Making schema changes**. Since libSQL uses HTTP to connect to the remote database, this makes it incompatible with Prisma Migrate. However, you can use [`prisma migrate diff`](/reference/api-reference/command-reference#migrate-diff) to create a schema migration and then apply the changes to your database using [Turso's CLI](https://docs.turso.tech/reference/turso-cli).
+- **Making schema changes**. Since libSQL uses HTTP to connect to the remote database, this makes it incompatible with Prisma Migrate. However, you can use [`prisma migrate diff`](/orm/reference/prisma-cli-reference#migrate-diff) to create a schema migration and then apply the changes to your database using [Turso's CLI](https://docs.turso.tech/reference/turso-cli).
## How to connect and query a Turso database
diff --git a/content/200-concepts/100-components/images/drivers/qe-query-engine-adapter.png b/content/200-orm/050-overview/500-databases/images/drivers/qe-query-engine-adapter.png
similarity index 100%
rename from content/200-concepts/100-components/images/drivers/qe-query-engine-adapter.png
rename to content/200-orm/050-overview/500-databases/images/drivers/qe-query-engine-adapter.png
diff --git a/content/200-concepts/100-components/images/drivers/qe-query-execution-flow.png b/content/200-orm/050-overview/500-databases/images/drivers/qe-query-execution-flow.png
similarity index 100%
rename from content/200-concepts/100-components/images/drivers/qe-query-execution-flow.png
rename to content/200-orm/050-overview/500-databases/images/drivers/qe-query-execution-flow.png
diff --git a/content/300-guides/050-database/images/embedded-replica-create-replica.png b/content/200-orm/050-overview/500-databases/images/embedded-replica-create-replica.png
similarity index 100%
rename from content/300-guides/050-database/images/embedded-replica-create-replica.png
rename to content/200-orm/050-overview/500-databases/images/embedded-replica-create-replica.png
diff --git a/content/300-guides/050-database/images/embedded-replica-read.png b/content/200-orm/050-overview/500-databases/images/embedded-replica-read.png
similarity index 100%
rename from content/300-guides/050-database/images/embedded-replica-read.png
rename to content/200-orm/050-overview/500-databases/images/embedded-replica-read.png
diff --git a/content/300-guides/050-database/images/embedded-replica-remote-read.png b/content/200-orm/050-overview/500-databases/images/embedded-replica-remote-read.png
similarity index 100%
rename from content/300-guides/050-database/images/embedded-replica-remote-read.png
rename to content/200-orm/050-overview/500-databases/images/embedded-replica-remote-read.png
diff --git a/content/300-guides/050-database/images/embedded-replica-write-propagation.png b/content/200-orm/050-overview/500-databases/images/embedded-replica-write-propagation.png
similarity index 100%
rename from content/300-guides/050-database/images/embedded-replica-write-propagation.png
rename to content/200-orm/050-overview/500-databases/images/embedded-replica-write-propagation.png
diff --git a/content/200-orm/050-overview/500-databases/index.mdx b/content/200-orm/050-overview/500-databases/index.mdx
new file mode 100644
index 0000000000..81680e00f6
--- /dev/null
+++ b/content/200-orm/050-overview/500-databases/index.mdx
@@ -0,0 +1,16 @@
+---
+title: 'Databases'
+metaTitle: 'Databases'
+metaDescription: 'Databases'
+toc: false
+---
+
+
+
+Learn about the different databases Prisma supports.
+
+
+
+## In this section
+
+
diff --git a/content/200-concepts/200-database-connectors/mongodb.png b/content/200-orm/050-overview/500-databases/mongodb.png
similarity index 100%
rename from content/200-concepts/200-database-connectors/mongodb.png
rename to content/200-orm/050-overview/500-databases/mongodb.png
diff --git a/content/200-concepts/200-database-connectors/mysql-connection-string.png b/content/200-orm/050-overview/500-databases/mysql-connection-string.png
similarity index 100%
rename from content/200-concepts/200-database-connectors/mysql-connection-string.png
rename to content/200-orm/050-overview/500-databases/mysql-connection-string.png
diff --git a/content/200-concepts/200-database-connectors/postgresql-connection-string.png b/content/200-orm/050-overview/500-databases/postgresql-connection-string.png
similarity index 100%
rename from content/200-concepts/200-database-connectors/postgresql-connection-string.png
rename to content/200-orm/050-overview/500-databases/postgresql-connection-string.png
diff --git a/content/200-concepts/050-overview/index.mdx b/content/200-orm/050-overview/index.mdx
similarity index 82%
rename from content/200-concepts/050-overview/index.mdx
rename to content/200-orm/050-overview/index.mdx
index c0fd57780b..89077e1d99 100644
--- a/content/200-concepts/050-overview/index.mdx
+++ b/content/200-orm/050-overview/index.mdx
@@ -6,6 +6,7 @@ staticLink: true
toc: false
---
+
## In this section
-
+
diff --git a/content/200-concepts/100-components/01-prisma-schema/02-data-sources.mdx b/content/200-orm/100-prisma-schema/10-overview/02-data-sources.mdx
similarity index 62%
rename from content/200-concepts/100-components/01-prisma-schema/02-data-sources.mdx
rename to content/200-orm/100-prisma-schema/10-overview/02-data-sources.mdx
index d36e7e64b3..7ff9a664d8 100644
--- a/content/200-concepts/100-components/01-prisma-schema/02-data-sources.mdx
+++ b/content/200-orm/100-prisma-schema/10-overview/02-data-sources.mdx
@@ -6,7 +6,7 @@ metaDescription: 'Data sources enable Prisma to connect to your database. This p
-A data source determines how Prisma connects your database, and is represented by the [`datasource`](/reference/api-reference/prisma-schema-reference#datasource) block in the Prisma schema. The following data source uses the `postgresql` provider and includes a connection URL:
+A data source determines how Prisma connects your database, and is represented by the [`datasource`](/orm/reference/prisma-schema-reference#datasource) block in the Prisma schema. The following data source uses the `postgresql` provider and includes a connection URL:
```prisma
datasource db {
@@ -17,8 +17,8 @@ datasource db {
A Prisma schema can only have _one_ data source. However, you can:
-- [Programmatically override a data source `url` when creating your `PrismaClient`](/reference/api-reference/prisma-client-reference#programmatically-override-a-datasource-url)
-- [Specify a different URL for Prisma Migrate's shadow database if you are working with cloud-hosted development databases](/concepts/components/prisma-migrate/shadow-database#cloud-hosted-shadow-databases-must-be-created-manually)
+- [Programmatically override a data source `url` when creating your `PrismaClient`](/orm/reference/prisma-client-reference#programmatically-override-a-datasource-url)
+- [Specify a different URL for Prisma Migrate's shadow database if you are working with cloud-hosted development databases](/orm/prisma-migrate/understanding-prisma-migrate/shadow-database#cloud-hosted-shadow-databases-must-be-created-manually)
> **Note**: Multiple provider support was removed in 2.22.0. Please see [Deprecation of provider array notation](https://github.com/prisma/prisma/issues/3834) for more information.
@@ -28,9 +28,9 @@ A Prisma schema can only have _one_ data source. However, you can:
Some data source `provider`s allow you to configure your connection with SSL/TLS, and provide parameters for the `url` to specify the location of certificates.
-- [Configuring an SSL connection with PostgreSQL](/concepts/database-connectors/postgresql#configuring-an-ssl-connection)
-- [Configuring an SSL connection with MySQL](/concepts/database-connectors/mysql#configuring-an-ssl-connection)
-- [Configure a TLS connection with Microsoft SQL Server](/concepts/database-connectors/sql-server#connection-details)
+- [Configuring an SSL connection with PostgreSQL](/orm/overview/databases/postgresql#configuring-an-ssl-connection)
+- [Configuring an SSL connection with MySQL](/orm/overview/databases/mysql#configuring-an-ssl-connection)
+- [Configure a TLS connection with Microsoft SQL Server](/orm/overview/databases/sql-server#connection-details)
Prisma resolves SSL certificates relative to the `./prisma` directory. If your certificate files are located outside that directory, e.g. your project root directory, use relative paths for certificates:
diff --git a/content/200-concepts/100-components/01-prisma-schema/03-generators.mdx b/content/200-orm/100-prisma-schema/10-overview/03-generators.mdx
similarity index 93%
rename from content/200-concepts/100-components/01-prisma-schema/03-generators.mdx
rename to content/200-orm/100-prisma-schema/10-overview/03-generators.mdx
index 51a192d22f..c7190aef04 100644
--- a/content/200-concepts/100-components/01-prisma-schema/03-generators.mdx
+++ b/content/200-orm/100-prisma-schema/10-overview/03-generators.mdx
@@ -6,7 +6,7 @@ metaDescription: 'Generators in your Prisma schema specify what assets are gener
-A Prisma schema can have one or more generators, represented by the [`generator`](/reference/api-reference/prisma-schema-reference#generator) block:
+A Prisma schema can have one or more generators, represented by the [`generator`](/orm/reference/prisma-schema-reference#generator) block:
```prisma
generator client {
@@ -23,7 +23,7 @@ A generator determines which assets are created when you run the `prisma generat
The generator for Prisma's JavaScript Client accepts multiple additional properties:
-- `previewFeatures`: [Preview features](/concepts/components/preview-features) to include
+- `previewFeatures`: [Preview features](/orm/reference/preview-features) to include
- `binaryTargets`: Engine binary targets for `prisma-client-js` (for example, `debian-openssl-1.1.x` if you are deploying to Ubuntu 18+, or `native` if you are working locally)
```prisma
@@ -38,7 +38,7 @@ generator client {
Prisma Client JS (`prisma-client-js`) uses several [engines](https://github.com/prisma/prisma-engines). Engines are implemented in Rust and are used by Prisma in the form of executable, platform dependent engine files. Depending on which platform you are executing your code on, you need the correct file. "Binary targets" are used to define which files should be present for the target platform(s).
-The correct file is particularly important when [deploying](/guides/deployment/deploy-prisma) your application to production, which often differs from your local development environment.
+The correct file is particularly important when [deploying](/orm/prisma-client/deployment/deploy-prisma) your application to production, which often differs from your local development environment.
#### The `native` binary target
@@ -53,11 +53,11 @@ generator client {
}
```
-In that case, Prisma detects your operating system and finds the right binary file for it based on the [list of supported operating systems](/reference/api-reference/prisma-schema-reference#binarytargets-options) .
+In that case, Prisma detects your operating system and finds the right binary file for it based on the [list of supported operating systems](/orm/reference/prisma-schema-reference#binarytargets-options) .
If you use macOS Intel x86 (`darwin`), then the binary file that was compiled for `darwin` will be selected.
If you use macOS ARM64 (`darwin-arm64`), then the binary file that was compiled for `darwin-arm64` will be selected.
-> **Note**: The `native` binary target is the default. You can set it explicitly if you wish to [include additional binary targets for deployment to different environments](/guides/deployment/use-prisma-with-serverless-framework#binary-targets-in-schemaprisma).
+> **Note**: The `native` binary target is the default. You can set it explicitly if you wish to include additional [binary targets](/orm/reference/prisma-schema-reference#binarytargets-options) for deployment to different environments.
## Community generators
@@ -96,4 +96,3 @@ The following is a list of community created generators. If you want to create y
- [`prisma-markdown`](https://github.com/samchon/prisma-markdown): Generates markdown document composed with ERD diagrams and their descriptions. Supports pagination of ERD diagrams through `@namespace` comment tag.
- [`prisma-models-graph`](https://github.com/dangchinh25/prisma-models-graph): Generates a bi-directional models graph for schema without strict relationship defined in the schema, works via a custom schema annotation.
- [`prisma-generator-fake-data`](https://github.com/luisrudge/prisma-generator-fake-data): Generates realistic-looking fake data for your Prisma models that can be used in unit/integration tests, demos, and more.
-
diff --git a/content/200-concepts/100-components/01-prisma-schema/index.mdx b/content/200-orm/100-prisma-schema/10-overview/index.mdx
similarity index 87%
rename from content/200-concepts/100-components/01-prisma-schema/index.mdx
rename to content/200-orm/100-prisma-schema/10-overview/index.mdx
index 65e49e632e..5fd18d05bb 100644
--- a/content/200-concepts/100-components/01-prisma-schema/index.mdx
+++ b/content/200-orm/100-prisma-schema/10-overview/index.mdx
@@ -1,6 +1,6 @@
---
-title: 'Prisma schema'
-metaTitle: 'Prisma schema (Reference)'
+title: 'Overview'
+metaTitle: 'Prisma Schema Overview'
metaDescription: 'The Prisma schema is the main configuration file when using Prisma. It is typically called schema.prisma and contains your database connection and data model.'
---
@@ -10,9 +10,9 @@ The Prisma schema file (short: _schema file_, _Prisma schema_ or _schema_) is th
- [**Data sources**](data-sources): Specify the details of the data sources Prisma should connect to (e.g. a PostgreSQL database)
- [**Generators**](generators): Specifies what clients should be generated based on the data model (e.g. Prisma Client)
-- [**Data model definition**](/concepts/components/prisma-schema/data-model): Specifies your application [models](/concepts/components/prisma-schema/data-model#defining-models) (the shape of the data per data source) and their [relations](relations)
+- [**Data model definition**](/orm/prisma-schema/data-model): Specifies your application [models](/orm/prisma-schema/data-model/models#defining-models) (the shape of the data per data source) and their [relations](/orm/prisma-schema/data-model/relations)
-See the [Prisma schema API reference](/reference/api-reference/prisma-schema-reference) for detailed information about each section of the schema.
+See the [Prisma schema API reference](/orm/reference/prisma-schema-reference) for detailed information about each section of the schema.
Whenever a `prisma` command is invoked, the CLI typically reads some information from the schema file, e.g.:
@@ -30,7 +30,7 @@ The following is an example of a Prisma schema file that specifies:
- A data source (PostgreSQL or MongoDB)
- A generator (Prisma Client)
- A data model definition with two models (with one relation) and one `enum`
-- Several [native data type attributes](/concepts/components/prisma-schema/data-model#native-types-mapping) (`@db.VarChar(255)`, `@db.ObjectId`)
+- Several [native data type attributes](/orm/prisma-schema/data-model/models#native-types-mapping) (`@db.VarChar(255)`, `@db.ObjectId`)
, ]}>
@@ -127,7 +127,7 @@ The schema file is written in Prisma Schema Language (PSL).
### VS Code
-Syntax highlighting for PSL is available via a [VS Code extension](https://marketplace.visualstudio.com/items?itemName=Prisma.prisma) (which also lets you auto-format the contents of your Prisma schema and indicates syntax errors with red squiggly lines). Learn more about [setting up Prisma in your editor](/guides/development-environment/editor-setup).
+Syntax highlighting for PSL is available via a [VS Code extension](https://marketplace.visualstudio.com/items?itemName=Prisma.prisma) (which also lets you auto-format the contents of your Prisma schema and indicates syntax errors with red squiggly lines). Learn more about [setting up Prisma in your editor](/orm/more/development-environment/editor-setup).
### GitHub
@@ -148,7 +148,7 @@ model User {
The Prisma CLI looks for the Prisma schema file in the following locations, in the following order:
-1. The location specified by the [`--schema` flag](/reference/api-reference/command-reference), which is available when you `introspect`, `generate`, `migrate`, and `studio`:
+1. The location specified by the [`--schema` flag](/orm/reference/prisma-cli-reference), which is available when you `introspect`, `generate`, `migrate`, and `studio`:
```terminal
prisma generate --schema=./alternative/schema.prisma
@@ -200,7 +200,7 @@ You can use the `env()` function in the following places:
- A datasource url
- Generator binary targets
-See [Environment variables](/guides/development-environment/environment-variables) for more information about how to use an `.env` file during development.
+See [Environment variables](/orm/more/development-environment/environment-variables) for more information about how to use an `.env` file during development.
## Comments
@@ -232,7 +232,7 @@ model Customer {}
Prisma supports formatting `.prisma` files automatically. There are two ways to format `.prisma` files:
-- Run the [`prisma format`](/reference/api-reference/command-reference#format) command.
+- Run the [`prisma format`](/orm/reference/prisma-cli-reference#format) command.
- Install the [Prisma VS Code extension](https://marketplace.visualstudio.com/items?itemName=Prisma.prisma) and invoke the [VS Code format action](https://code.visualstudio.com/docs/editor/codebasics#_formatting) - manually or on save.
There are no configuration options - [formatting rules](#formatting-rules) are fixed (similar to Golang's `gofmt` but unlike Javascript's `prettier`):
diff --git a/content/200-concepts/100-components/01-prisma-schema/04-data-model.mdx b/content/200-orm/100-prisma-schema/20-data-model/10-models.mdx
similarity index 69%
rename from content/200-concepts/100-components/01-prisma-schema/04-data-model.mdx
rename to content/200-orm/100-prisma-schema/20-data-model/10-models.mdx
index 32a5758ca3..9f21cb3958 100644
--- a/content/200-concepts/100-components/01-prisma-schema/04-data-model.mdx
+++ b/content/200-orm/100-prisma-schema/20-data-model/10-models.mdx
@@ -1,18 +1,18 @@
---
-title: 'Data model'
-metaTitle: 'Data model (Reference)'
+title: 'Models'
+metaTitle: 'Models'
metaDescription: 'Learn about the concepts for building your data model with Prisma: Models, scalar types, enums, attributes, functions, IDs, default values and more.'
tocDepth: 3
---
-The data model definition part of the [Prisma schema](./) defines your application models (also called **Prisma models**). Models:
+The data model definition part of the [Prisma schema](/orm/prisma-schema) defines your application models (also called **Prisma models**). Models:
- Represent the **entities** of your application domain
- Map to the **tables** (relational databases like PostgreSQL) or **collections** (MongoDB) in your database
-- Form the foundation of the **queries** available in the generated [Prisma Client API](/concepts/components/prisma-client)
-- When used with TypeScript, Prisma Client provides generated **type definitions** for your models and any [variations](/concepts/components/prisma-client/advanced-type-safety/operating-against-partial-structures-of-model-types) of them to make database access entirely type safe.
+- Form the foundation of the **queries** available in the generated [Prisma Client API](/orm/prisma-client)
+- When used with TypeScript, Prisma Client provides generated **type definitions** for your models and any [variations](/orm/prisma-client/type-safety/operating-against-partial-structures-of-model-types) of them to make database access entirely type safe.
The following schema describes a blogging platform - the data model definition is highlighted:
@@ -98,22 +98,23 @@ model Profile {
}
model Post {
- id String @id @default(auto()) @map("_id") @db.ObjectId
- createdAt DateTime @default(now())
- title String
- published Boolean @default(false)
- author User @relation(fields: [authorId], references: [id])
- authorId String @db.ObjectId
+ id String @id @default(auto()) @map("_id") @db.ObjectId
+ createdAt DateTime @default(now())
+ title String
+ published Boolean @default(false)
+ author User @relation(fields: [authorId], references: [id])
+ authorId String @db.ObjectId
categoryIDs String[] @db.ObjectId
categories Category[] @relation(fields: [categoryIDs], references: [id])
}
model Category {
- id String @id @default(auto()) @map("_id") @db.ObjectId
- name String
+ id String @id @default(auto()) @map("_id") @db.ObjectId
+ name String
postIDs String[] @db.ObjectId
posts Post[] @relation(fields: [postIDs], references: [id])
}
+
enum Role {
USER
ADMIN
@@ -125,13 +126,13 @@ enum Role {
The data model definition is made up of:
-- [Models](#defining-models) ([`model`](/reference/api-reference/prisma-schema-reference#model) primitives) that define a number of fields, including [relations between models](#relation-fields)
-- [Enums](#defining-enums) ([`enum`](/reference/api-reference/prisma-schema-reference#enum) primitives) (if your connector supports Enums)
+- [Models](#defining-models) ([`model`](/orm/reference/prisma-schema-reference#model) primitives) that define a number of fields, including [relations between models](#relation-fields)
+- [Enums](#defining-enums) ([`enum`](/orm/reference/prisma-schema-reference#enum) primitives) (if your connector supports Enums)
- [Attributes](#defining-attributes) and [functions](#using-functions) that change the behavior of fields and models
The corresponding database looks like this:
-
+
A model maps to the underlying structures of the data source.
@@ -251,12 +252,12 @@ Your data model reflects _your_ application domain. For example:
There are two ways to define a data model:
-- **Write the data model manually and use Prisma Migrate**: You can write your data model manually and map it to your database using [Prisma Migrate](/concepts/components/prisma-migrate). In this case, the data model is the single source of truth for the models of your application.
-- **Generate the data model via introspection**: When you have an existing database or prefer migrating your database schema with SQL, you generate the data model by [introspecting](/concepts/components/introspection) your database. In this case, the database schema is the single source of truth for the models of your application.
+- **Write the data model manually and use Prisma Migrate**: You can write your data model manually and map it to your database using [Prisma Migrate](/orm/prisma-migrate). In this case, the data model is the single source of truth for the models of your application.
+- **Generate the data model via introspection**: When you have an existing database or prefer migrating your database schema with SQL, you generate the data model by [introspecting](/orm/prisma-schema/introspection) your database. In this case, the database schema is the single source of truth for the models of your application.
## Defining models
-Models represent the entities of your application domain. Models are represented by [`model`](/reference/api-reference/prisma-schema-reference#model) blocks and define a number of [fields](/reference/api-reference/prisma-schema-reference#model-fields). In the [example data model](data-model), `User`, `Profile`, `Post` and `Category` are models.
+Models represent the entities of your application domain. Models are represented by [`model`](/orm/reference/prisma-schema-reference#model) blocks and define a number of [fields](/orm/reference/prisma-schema-reference#model-fields). In the example data model above, `User`, `Profile`, `Post` and `Category` are models.
A blogging platform can be extended with the following models:
@@ -272,7 +273,7 @@ model Tag {
### Mapping model names to tables or collections
-Prisma model [naming conventions (singular form, PascalCase)](/reference/api-reference/prisma-schema-reference#naming-conventions) do not always match table names in the database. A common approach for naming tables/collections in databases is to use plural form and [snake_case](https://en.wikipedia.org/wiki/Snake_case) notation - for example: `comments`. When you introspect a database with a table named `comments`, the result Prisma model will look like this:
+Prisma model [naming conventions (singular form, PascalCase)](/orm/reference/prisma-schema-reference#naming-conventions) do not always match table names in the database. A common approach for naming tables/collections in databases is to use plural form and [snake_case](https://en.wikipedia.org/wiki/Snake_case) notation - for example: `comments`. When you introspect a database with a table named `comments`, the result Prisma model will look like this:
```prisma
model comments {
@@ -280,7 +281,7 @@ model comments {
}
```
-However, you can still adhere to the naming convention without renaming the underlying `comments` table in the database by using the [`@@map`](/reference/api-reference/prisma-schema-reference#map-1) attribute:
+However, you can still adhere to the naming convention without renaming the underlying `comments` table in the database by using the [`@@map`](/orm/reference/prisma-schema-reference#map-1) attribute:
```prisma
model Comment {
@@ -292,9 +293,9 @@ model Comment {
With this model definition, Prisma automatically maps the `Comment` model to the `comments` table in the underlying database.
-> **Note**: You can also [`@map`](/reference/api-reference/prisma-schema-reference#map) a column name or enum value, and `@@map` an enum name.
+> **Note**: You can also [`@map`](/orm/reference/prisma-schema-reference#map) a column name or enum value, and `@@map` an enum name.
-`@map` and `@@map` allow you to [tune the shape of your Prisma Client API](/concepts/components/prisma-client/working-with-prismaclient/use-custom-model-and-field-names#using-map-and-map-to-rename-fields-and-models-in-the-prisma-client-api) by decoupling model and field names from table and column names in the underlying database.
+`@map` and `@@map` allow you to [tune the shape of your Prisma Client API](/orm/prisma-client/setup-and-configuration/custom-model-and-field-names#using-map-and-map-to-rename-fields-and-models-in-the-prisma-client-api) by decoupling model and field names from table and column names in the underlying database.
@@ -313,14 +314,14 @@ With this model definition, Prisma automatically maps the `Comment` model to the
The properties of a model are called _fields_, which consist of:
-- A **[field name](/reference/api-reference/prisma-schema-reference#model-fields)**
-- A **[field type](/reference/api-reference/prisma-schema-reference#model-fields)**
+- A **[field name](/orm/reference/prisma-schema-reference#model-fields)**
+- A **[field type](/orm/reference/prisma-schema-reference#model-fields)**
- Optional **[type modifiers](#type-modifiers)**
- Optional **[attributes](#defining-attributes)**, including [native database type attributes](#native-types-mapping)
A field's type determines its _structure_, and fits into one of two categories:
-- [Scalar types](data-model#scalar-fields) (includes [enums](data-model#defining-enums)) that map to columns (relational databases) or document fields (MongoDB) in the database - for example, [`String`](/reference/api-reference/prisma-schema-reference#string)
or [`Int`](/reference/api-reference/prisma-schema-reference#int)
+- [Scalar types](#scalar-fields) (includes [enums](#defining-enums)) that map to columns (relational databases) or document fields (MongoDB) in the database - for example, [`String`](/orm/reference/prisma-schema-reference#string) or [`Int`](/orm/reference/prisma-schema-reference#int)
- Model types (the field is then called [relation field](relations#relation-fields)) - for example `Post` or `Comment[]`.
The following table describes `User` model's fields from the sample schema:
@@ -375,7 +376,7 @@ model Tag {
-See [complete list of scalar field types](/reference/api-reference/prisma-schema-reference#model-field-scalar-types)
.
+See [complete list of scalar field types](/orm/reference/prisma-schema-reference#model-field-scalar-types) .
### Relation fields
@@ -440,21 +441,21 @@ Type attributes are:
- Written in PascalCase (for example, `VarChar` or `Text`)
- Prefixed by `@db`, where `db` is the name of the `datasource` block in your schema
-Furthermore, during [Introspection](/concepts/components/introspection) type attributes are _only_ added to the schema if the underlying native type is **not the default type**. For example, if you are using the PostgreSQL provider, `String` fields where the underlying native type is `text` will not have a type attribute.
+Furthermore, during [Introspection](/orm/prisma-schema/introspection) type attributes are _only_ added to the schema if the underlying native type is **not the default type**. For example, if you are using the PostgreSQL provider, `String` fields where the underlying native type is `text` will not have a type attribute.
-See [complete list of native database type attributes per scalar type and provider](/reference/api-reference/prisma-schema-reference#model-field-scalar-types)
.
+See [complete list of native database type attributes per scalar type and provider](/orm/reference/prisma-schema-reference#model-field-scalar-types) .
#### Benefits and workflows
-- Control **the exact native type** that [Prisma Migrate](/concepts/components/prisma-migrate) creates in the database - for example, a `String` can be `@db.VarChar(200)` or `@db.Char(50)`
+- Control **the exact native type** that [Prisma Migrate](/orm/prisma-migrate) creates in the database - for example, a `String` can be `@db.VarChar(200)` or `@db.Char(50)`
- See an **enriched schema** when you introspect
### Type modifiers
The type of a field can be modified by appending either of two modifiers:
-- [`[]`](/reference/api-reference/prisma-schema-reference#-modifier)
Make a field a list
-- [`?`](/reference/api-reference/prisma-schema-reference#-modifier-1)
Make a field optional
+- [`[]`](/orm/reference/prisma-schema-reference#-modifier) Make a field a list
+- [`?`](/orm/reference/prisma-schema-reference#-modifier-1) Make a field optional
> **Note**: You **cannot** combine type modifiers - optional lists are not supported.
@@ -537,7 +538,7 @@ When **not** annotating a field with the `?` type modifier, the field will be _r
### Unsupported types
-When you introspect a relational database, unsupported data types are added as [`Unsupported`](/reference/api-reference/prisma-schema-reference#unsupported)
:
+When you introspect a relational database, unsupported data types are added as [`Unsupported`](/orm/reference/prisma-schema-reference#unsupported) :
```prisma
location Unsupported("POLYGON")?
@@ -545,7 +546,7 @@ location Unsupported("POLYGON")?
The `Unsupported` type allows you to define fields in the Prisma schema for database types that are not yet supported by Prisma. For example, MySQL's `POLYGON` type is not currently supported by Prisma, but can now be added to the Prisma schema using the `Unsupported("POLYGON")` type.
-Fields of type `Unsupported` are not available in the generated Prisma Client API, but you can still use Prisma's [raw database access](/concepts/components/prisma-client/raw-database-access) feature to query these fields.
+Fields of type `Unsupported` are not available in the generated Prisma Client API, but you can still use Prisma's [raw database access](/orm/prisma-client/queries/raw-database-access/raw-queries) feature to query these fields.
> **Note**: If a model has **mandatory `Unsupported` fields**, the generated client will not include `create` or `update` methods for that model.
@@ -553,7 +554,7 @@ Fields of type `Unsupported` are not available in the generated Prisma Client AP
## Defining attributes
-Attributes modify the behavior of fields or model blocks. The following example includes three field attributes ([`@id`](/reference/api-reference/prisma-schema-reference#id)
, [`@default`](/reference/api-reference/prisma-schema-reference#default)
, and [`@unique`](/reference/api-reference/prisma-schema-reference#unique)
) and one block attribute ([`@@unique`](/reference/api-reference/prisma-schema-reference#unique-1)
):
+Attributes modify the behavior of fields or model blocks. The following example includes three field attributes ([`@id`](/orm/reference/prisma-schema-reference#id) , [`@default`](/orm/reference/prisma-schema-reference#default) , and [`@unique`](/orm/reference/prisma-schema-reference#unique) ) and one block attribute ([`@@unique`](/orm/reference/prisma-schema-reference#unique-1) ):
,
]}>
@@ -588,13 +589,13 @@ model User {
-Some attributes accept [arguments](/reference/api-reference/prisma-schema-reference#attribute-argument-types)
- for example, `@default` accepts `true` or `false`:
+Some attributes accept [arguments](/orm/reference/prisma-schema-reference#attribute-argument-types) - for example, `@default` accepts `true` or `false`:
```prisma
isAdmin Boolean @default(false) // short form of @default(value: false)
```
-See [complete list of field and block attributes](/reference/api-reference/prisma-schema-reference#attributes)
+See [complete list of field and block attributes](/orm/reference/prisma-schema-reference#attributes)
### Defining an ID field
@@ -605,7 +606,7 @@ An ID uniquely identifies individual records of a model. A model can only have _
#### Defining IDs in relational databases
-In relational databases, an ID can be defined by a single field using the [`@id`](/reference/api-reference/prisma-schema-reference#id)
attribute, or multiple fields using the [`@@id`](/reference/api-reference/prisma-schema-reference#id-1)
attribute.
+In relational databases, an ID can be defined by a single field using the [`@id`](/orm/reference/prisma-schema-reference#id) attribute, or multiple fields using the [`@@id`](/orm/reference/prisma-schema-reference#id-1) attribute.
##### Single field IDs
@@ -639,7 +640,7 @@ model User {
By default, the name of this field in Prisma Client queries will be `firstName_lastName`.
-You can also provide your own name for the composite ID using the [`@@id`](/reference/api-reference/prisma-schema-reference#id-1)
attribute's `name` field:
+You can also provide your own name for the composite ID using the [`@@id`](/orm/reference/prisma-schema-reference#id-1) attribute's `name` field:
```prisma highlight=7;normal
model User {
@@ -656,7 +657,7 @@ The `firstName_lastName` field will now be named `fullName` instead.
-Refer to the documentation on [working with composite IDs](/concepts/components/prisma-client/working-with-fields/working-with-composite-ids-and-constraints) to learn how to interact with a composite ID in Prisma Client.
+Refer to the documentation on [working with composite IDs](/orm/prisma-client/special-fields-and-types/working-with-composite-ids-and-constraints) to learn how to interact with a composite ID in Prisma Client.
@@ -677,13 +678,13 @@ model User {
**Constraint names in relational databases**
-You can optionally define a [custom primary key constraint name](/concepts/components/prisma-schema/names-in-underlying-database#constraint-and-index-names) in the underlying database.
+You can optionally define a [custom primary key constraint name](/orm/prisma-schema/data-model/database-mapping#constraint-and-index-names) in the underlying database.
#### Defining IDs in MongoDB
-The MongoDB connector has [specific rules for defining an ID field](/reference/api-reference/prisma-schema-reference#mongodb)
that differs from relational databases. An ID must be defined by a single field using the [`@id`](/reference/api-reference/prisma-schema-reference#id)
attribute and must include `@map("_id")`.
+The MongoDB connector has [specific rules for defining an ID field](/orm/reference/prisma-schema-reference#mongodb) that differs from relational databases. An ID must be defined by a single field using the [`@id`](/orm/reference/prisma-schema-reference#id) attribute and must include `@map("_id")`.
In the following example, the `User` ID is represented by the `id` string field that accepts an auto-generated `ObjectId`:
@@ -720,7 +721,7 @@ MongoDB does not support composite IDs, which means you cannot identify a model
### Defining a default value
-You can define default values for scalar fields of your models using the [`@default`](/reference/api-reference/prisma-schema-reference#default)
attribute:
+You can define default values for scalar fields of your models using the [`@default`](/orm/reference/prisma-schema-reference#default) attribute:
,
]}>
@@ -758,23 +759,23 @@ model Post {
`@default` attributes either:
- Represent `DEFAULT` values in the underlying database (relational databases only) _or_
-- Use a Prisma-level function. For example, `cuid()` and `uuid()` are provided by Prisma's [query engine](/concepts/components/prisma-engines/query-engine) for all connectors.
+- Use a Prisma-level function. For example, `cuid()` and `uuid()` are provided by Prisma's [query engine](/orm/more/under-the-hood/engines) for all connectors.
Default values can be:
- Static values that correspond to the field type, such as `5` (`Int`), `Hello` (`String`), or `false` (`Boolean`)
-- [Lists](/reference/api-reference/prisma-schema-reference#-modifier) of static values, such as `[5, 6, 8]` (`Int[]`) or `["Hello", "Goodbye"]` (`String`[]). These are available in versions `4.0.0` and later, when using databases where Prisma supports them (PostgreSQL, CockroachDB and MongoDB)
-- [Functions](#using-functions), such as [`now()`](/reference/api-reference/prisma-schema-reference#now) or [`uuid()`](/reference/api-reference/prisma-schema-reference#uuid)
+- [Lists](/orm/reference/prisma-schema-reference#-modifier) of static values, such as `[5, 6, 8]` (`Int[]`) or `["Hello", "Goodbye"]` (`String`[]). These are available in versions `4.0.0` and later, when using databases where Prisma supports them (PostgreSQL, CockroachDB and MongoDB)
+- [Functions](#using-functions), such as [`now()`](/orm/reference/prisma-schema-reference#now) or [`uuid()`](/orm/reference/prisma-schema-reference#uuid)
-Refer to the [attribute function reference documentation](/reference/api-reference/prisma-schema-reference#attribute-functions) for information about connector support for functions.
+Refer to the [attribute function reference documentation](/orm/reference/prisma-schema-reference#attribute-functions) for information about connector support for functions.
### Defining a unique field
-You can add unique attributes to your models to be able to uniquely identify individual records of that model. Unique attributes can be defined on a single field using [`@unique`](/reference/api-reference/prisma-schema-reference#unique) attribute, or on multiple fields (also called composite or compound unique constraints) using the [`@@unique`](/reference/api-reference/prisma-schema-reference#unique-1) attribute.
+You can add unique attributes to your models to be able to uniquely identify individual records of that model. Unique attributes can be defined on a single field using [`@unique`](/orm/reference/prisma-schema-reference#unique) attribute, or on multiple fields (also called composite or compound unique constraints) using the [`@@unique`](/orm/reference/prisma-schema-reference#unique-1) attribute.
In the following example, the value of the `email` field must be unique:
@@ -845,13 +846,13 @@ model Post {
**Constraint names in relational databases**
-You can optionally define a [custom unique constraint name](/concepts/components/prisma-schema/names-in-underlying-database#constraint-and-index-names) in the underlying database.
+You can optionally define a [custom unique constraint name](/orm/prisma-schema/data-model/database-mapping#constraint-and-index-names) in the underlying database.
By default, the name of this field in Prisma Client queries will be `authorId_title`.
-You can also provide your own name for the composite unique constraint using the [`@@unique`](/concepts/components/prisma-schema/names-in-underlying-database#constraint-and-index-names) attribute's `name` field:
+You can also provide your own name for the composite unique constraint using the [`@@unique`](/orm/prisma-schema/data-model/database-mapping#constraint-and-index-names) attribute's `name` field:
```prisma highlight=10;normal
model Post {
@@ -871,7 +872,7 @@ The `authorId_title` field will now be named `authorTitle` instead.
-Refer to the documentation on [working with composite unique identifiers](/concepts/components/prisma-client/working-with-fields/working-with-composite-ids-and-constraints) to learn how to interact with a composite unique constraints in Prisma Client.
+Refer to the documentation on [working with composite unique identifiers](/orm/prisma-client/special-fields-and-types/working-with-composite-ids-and-constraints) to learn how to interact with a composite unique constraints in Prisma Client.
@@ -918,7 +919,7 @@ model User {
### Defining an index
-You can define indexes on one or multiple fields of your models via the [`@@index`](/reference/api-reference/prisma-schema-reference#index) on a model. The following example defines a multi-column index based on the `title` and `content` field:
+You can define indexes on one or multiple fields of your models via the [`@@index`](/orm/reference/prisma-schema-reference#index) on a model. The following example defines a multi-column index based on the `title` and `content` field:
```prisma
model Post {
@@ -933,7 +934,7 @@ model Post {
**Index names in relational databases**
-You can optionally define a [custom index name](/concepts/components/prisma-schema/names-in-underlying-database#constraint-and-index-names) in the underlying database.
+You can optionally define a [custom index name](/orm/prisma-schema/data-model/database-mapping#constraint-and-index-names) in the underlying database.
@@ -980,11 +981,11 @@ model User {
## Defining enums
-You can define enums in your data model [if enums are supported for your database connector](/reference/database-reference/database-features#misc), either natively or at Prisma level.
+You can define enums in your data model [if enums are supported for your database connector](/orm/reference/database-features#misc), either natively or at Prisma level.
-Enums are considered [scalar](#scalar-fields) types in the Prisma data model. They're therefore [by default](/concepts/components/prisma-client/select-fields#return-the-default-selection-set) included as return values in [Prisma Client queries](/concepts/components/prisma-client/crud).
+Enums are considered [scalar](#scalar-fields) types in the Prisma data model. They're therefore [by default](/orm/prisma-client/queries/select-fields#return-the-default-selection-set) included as return values in [Prisma Client queries](/orm/prisma-client/queries/crud).
-Enums are defined via the [`enum`](/reference/api-reference/prisma-schema-reference#enum) block. For example, a `User` has a `Role`:
+Enums are defined via the [`enum`](/orm/reference/prisma-schema-reference#enum) block. For example, a `User` has a `Role`:
, ]}>
@@ -1059,11 +1060,11 @@ In this case, the `Product` model has a list of `Photo` composite types stored i
### Considerations when using composite types
-Composite types only support a limited set of [attributes](/reference/api-reference/prisma-schema-reference#attributes). The following attributes are supported:
+Composite types only support a limited set of [attributes](/orm/reference/prisma-schema-reference#attributes). The following attributes are supported:
- `@default`
- `@map`
-- [Native types](/reference/api-reference/prisma-schema-reference#model-field-scalar-types), such as `@db.ObjectId`
+- [Native types](/orm/reference/prisma-schema-reference#model-field-scalar-types), such as `@db.ObjectId`
The following attributes are not supported inside composite types:
@@ -1079,9 +1080,9 @@ Indexes can be defined by using the `@@index` attribute on the level of the mode
## Using functions
-The Prisma schema supports a number of [functions](/reference/api-reference/prisma-schema-reference#attribute-functions) . These can be used to specify [default values](/reference/api-reference/prisma-schema-reference#default) on fields of a model.
+The Prisma schema supports a number of [functions](/orm/reference/prisma-schema-reference#attribute-functions) . These can be used to specify [default values](/orm/reference/prisma-schema-reference#default) on fields of a model.
-For example, the default value of `createdAt` is [`now()`](/reference/api-reference/prisma-schema-reference#now) :
+For example, the default value of `createdAt` is [`now()`](/orm/reference/prisma-schema-reference#now) :
, ]}>
@@ -1106,11 +1107,11 @@ model Post {
-[`cuid()`](/reference/api-reference/prisma-schema-reference#cuid) and [`uuid()`](/reference/api-reference/prisma-schema-reference#uuid) are implemented by Prisma and therefore are not "visible" in the underlying database schema. You can still use them when using [introspection](/concepts/components/introspection) by [manually changing your Prisma schema](/concepts/components/prisma-client/working-with-prismaclient/use-custom-model-and-field-names) and [generating Prisma Client](/concepts/components/prisma-client/working-with-prismaclient/generating-prisma-client), in that case the values will be generated by Prisma's [query engine](/concepts/components/prisma-engines/query-engine)
+[`cuid()`](/orm/reference/prisma-schema-reference#cuid) and [`uuid()`](/orm/reference/prisma-schema-reference#uuid) are implemented by Prisma and therefore are not "visible" in the underlying database schema. You can still use them when using [introspection](/orm/prisma-schema/introspection) by [manually changing your Prisma schema](/orm/prisma-client/setup-and-configuration/custom-model-and-field-names) and [generating Prisma Client](/orm/prisma-client/setup-and-configuration/generating-prisma-client), in that case the values will be generated by Prisma's [query engine](/orm/more/under-the-hood/engines)
-Support for [`autoincrement()`](/reference/api-reference/prisma-schema-reference#autoincrement) , [`now()`](/reference/api-reference/prisma-schema-reference#now) and [`dbgenerated()`](/reference/api-reference/prisma-schema-reference#dbgenerated) differ between databases.
+Support for [`autoincrement()`](/orm/reference/prisma-schema-reference#autoincrement) , [`now()`](/orm/reference/prisma-schema-reference#now) and [`dbgenerated()`](/orm/reference/prisma-schema-reference#dbgenerated) differ between databases.
-**Relational database connectors** implement `autoincrement()`, `dbgenerated()`, and `now()` at database level. The **MongoDB connector** does not support `autoincrement()` or `dbgenerated()`, and `now()` is implemented at Prisma level. The [`auto()`](/reference/api-reference/prisma-schema-reference#auto) function is used to generate an `ObjectId`.
+**Relational database connectors** implement `autoincrement()`, `dbgenerated()`, and `now()` at database level. The **MongoDB connector** does not support `autoincrement()` or `dbgenerated()`, and `now()` is implemented at Prisma level. The [`auto()`](/orm/reference/prisma-schema-reference#auto) function is used to generate an `ObjectId`.
## Relations
@@ -1120,20 +1121,20 @@ Refer to the [relations documentation](relations) for more examples and informat
### Queries (CRUD)
-Every model in the data model definition will result in a number of CRUD queries in the generated [Prisma Client API](/concepts/components/prisma-client):
-
-- [`findMany`](/reference/api-reference/prisma-client-reference#findmany)
-- [`findFirst`](/reference/api-reference/prisma-client-reference#findfirst)
-- [`findFirstOrThrow`](/reference/api-reference/prisma-client-reference#findfirstorthrow)
-- [`findUnique`](/reference/api-reference/prisma-client-reference#findunique)
-- [`findUniqueOrThrow`](/reference/api-reference/prisma-client-reference#finduniqueorthrow)
-- [`create`](/reference/api-reference/prisma-client-reference#create)
-- [`update`](/reference/api-reference/prisma-client-reference#update)
-- [`upsert`](/reference/api-reference/prisma-client-reference#upsert)
-- [`delete`](/reference/api-reference/prisma-client-reference#delete)
-- [`createMany`](/reference/api-reference/prisma-client-reference#createmany)
-- [`updateMany`](/reference/api-reference/prisma-client-reference#updatemany)
-- [`deleteMany`](/reference/api-reference/prisma-client-reference#deletemany)
+Every model in the data model definition will result in a number of CRUD queries in the generated [Prisma Client API](/orm/prisma-client):
+
+- [`findMany`](/orm/reference/prisma-client-reference#findmany)
+- [`findFirst`](/orm/reference/prisma-client-reference#findfirst)
+- [`findFirstOrThrow`](/orm/reference/prisma-client-reference#findfirstorthrow)
+- [`findUnique`](/orm/reference/prisma-client-reference#findunique)
+- [`findUniqueOrThrow`](/orm/reference/prisma-client-reference#finduniqueorthrow)
+- [`create`](/orm/reference/prisma-client-reference#create)
+- [`update`](/orm/reference/prisma-client-reference#update)
+- [`upsert`](/orm/reference/prisma-client-reference#upsert)
+- [`delete`](/orm/reference/prisma-client-reference#delete)
+- [`createMany`](/orm/reference/prisma-client-reference#createmany)
+- [`updateMany`](/orm/reference/prisma-client-reference#updatemany)
+- [`deleteMany`](/orm/reference/prisma-client-reference#deletemany)
The operations are accessible via a generated property on the Prisma Client instance. By default the name of the property is the lowercase form of the model name, e.g. `user` for a `User` model or `post` for a `Post` model.
@@ -1150,9 +1151,9 @@ const allUsers = await prisma.user.findMany()
### Type definitions
-Prisma Client also generates **type definitions** that reflect your model structures. These are part of the generated [`@prisma/client`](/concepts/components/prisma-client/working-with-prismaclient/generating-prisma-client#the-prismaclient-npm-package) node module.
+Prisma Client also generates **type definitions** that reflect your model structures. These are part of the generated [`@prisma/client`](/orm/prisma-client/setup-and-configuration/generating-prisma-client#the-prismaclient-npm-package) node module.
-When using TypeScript, these type definitions ensure that all your database queries are entirely type safe and validated at compile-time (even partial queries using [`select`](/reference/api-reference/prisma-client-reference#select) or [`include`](/reference/api-reference/prisma-client-reference#include) ).
+When using TypeScript, these type definitions ensure that all your database queries are entirely type safe and validated at compile-time (even partial queries using [`select`](/orm/reference/prisma-client-reference#select) or [`include`](/orm/reference/prisma-client-reference#include) ).
Even when using plain JavaScript, the type definitions are still included in the `@prisma/client` node module, enabling features like [IntelliSense](https://code.visualstudio.com/docs/editor/intellisense)/autocompletion in your editor.
@@ -1169,4 +1170,13 @@ export type User = {
}
```
-Note that the relation fields `posts` and `profile` are not included in the type definition by default. However, if you need variations of the `User` type you can still define them using some of [Prisma Client's generated helper types](/concepts/components/prisma-client/working-with-prismaclient/generating-prisma-client) (in this case, these helper types would be called `UserGetIncludePayload` and `UserGetSelectPayload`).
+Note that the relation fields `posts` and `profile` are not included in the type definition by default. However, if you need variations of the `User` type you can still define them using some of [Prisma Client's generated helper types](/orm/prisma-client/setup-and-configuration/generating-prisma-client) (in this case, these helper types would be called `UserGetIncludePayload` and `UserGetSelectPayload`).
+
+## Limitations
+
+### Records must be uniquely identifiable
+
+Prisma currently only supports models that have at least one unique field or combination of fields. In practice, this means that every Prisma model must have either at least one of the following attributes:
+
+- `@id` or `@@id` for a single- or multi-field primary key constraint (max one per model)
+- `@unique` or `@@unique` for a single- or multi-field unique constraint
diff --git a/content/200-concepts/100-components/01-prisma-schema/06-relations/100-one-to-one-relations.mdx b/content/200-orm/100-prisma-schema/20-data-model/20-relations/100-one-to-one-relations.mdx
similarity index 97%
rename from content/200-concepts/100-components/01-prisma-schema/06-relations/100-one-to-one-relations.mdx
rename to content/200-orm/100-prisma-schema/20-data-model/20-relations/100-one-to-one-relations.mdx
index 00f8495a9a..35ac1c56c5 100644
--- a/content/200-concepts/100-components/01-prisma-schema/06-relations/100-one-to-one-relations.mdx
+++ b/content/200-orm/100-prisma-schema/20-data-model/20-relations/100-one-to-one-relations.mdx
@@ -51,7 +51,7 @@ model Profile {
The `userId` relation scalar is a direct representation of the foreign key in the underlying database. This one-to-one relation expresses the following:
-- "a user can have zero profiles or one profile" (because the `profile` field is [optional](/concepts/components/prisma-schema/data-model#type-modifiers) on `User`)
+- "a user can have zero profiles or one profile" (because the `profile` field is [optional](/orm/prisma-schema/data-model/models#type-modifiers) on `User`)
- "a profile must always be connected to one user"
In the previous example, the `user` relation field of the `Profile` model references the `id` field of the `User` model. You can also reference a different field. In this case, you need to mark the field with the `@unique` attribute, to guarantee that there is only a single `User` connected to each `Profile`. In the following example, the `user` field references an `email` field in the `User` model, which is marked with the `@unique` attribute:
@@ -101,7 +101,7 @@ In MySQL, you can create a foreign key with only an index on the referenced side
## Multi-field relations in relational databases
-In **relational databases only**, you can also use [multi-field IDs](/reference/api-reference/prisma-schema-reference#id-1) to define a 1-1 relation:
+In **relational databases only**, you can also use [multi-field IDs](/orm/reference/prisma-schema-reference#id-1) to define a 1-1 relation:
]}>
@@ -199,7 +199,7 @@ model User {
This restriction was introduced in 2.12.0.
-However, you can choose if the side of the relation _with_ a relation scalar should be optional or mandatory.
+However, you can choose if the side of the relation _with_ a relation scalar should be optional or mandatory.
### Mandatory 1-1 relation
diff --git a/content/200-concepts/100-components/01-prisma-schema/06-relations/200-one-to-many-relations.mdx b/content/200-orm/100-prisma-schema/20-data-model/20-relations/200-one-to-many-relations.mdx
similarity index 92%
rename from content/200-concepts/100-components/01-prisma-schema/06-relations/200-one-to-many-relations.mdx
rename to content/200-orm/100-prisma-schema/20-data-model/20-relations/200-one-to-many-relations.mdx
index 4fa18f2b39..62b1169d76 100644
--- a/content/200-concepts/100-components/01-prisma-schema/06-relations/200-one-to-many-relations.mdx
+++ b/content/200-orm/100-prisma-schema/20-data-model/20-relations/200-one-to-many-relations.mdx
@@ -49,7 +49,7 @@ model Post {
-> **Note** The `posts` field does not "manifest" in the underlying database schema. On the other side of the relation, the [annotated relation field](/concepts/components/prisma-schema/relations#relation-fields) `author` and its relation scalar `authorId` represent the side of the relation that stores the foreign key in the underlying database.
+> **Note** The `posts` field does not "manifest" in the underlying database schema. On the other side of the relation, the [annotated relation field](/orm/prisma-schema/data-model/relations#relation-fields) `author` and its relation scalar `authorId` represent the side of the relation that stores the foreign key in the underlying database.
This one-to-many relation expresses the following:
@@ -103,7 +103,7 @@ In MySQL, you can create a foreign key with only an index on the referenced side
## Multi-field relations in relational databases
-In **relational databases only**, you can also define this relation using [multi-field IDs](/reference/api-reference/prisma-schema-reference#id-1)/composite key:
+In **relational databases only**, you can also define this relation using [multi-field IDs](/orm/reference/prisma-schema-reference#id-1)/composite key:
]}>
@@ -204,8 +204,8 @@ In MongoDB, the only difference between a 1-1 and a 1-n is the number of documen
A 1-n-relation always has two relation fields:
-- a [list](/concepts/components/prisma-schema/data-model#type-modifiers) relation field which is _not_ annotated with `@relation`
-- the [annotated relation field](/concepts/components/prisma-schema/relations#annotated-relation-fields-and-relation-scalar-fields) (including its relation scalar)
+- a [list](/orm/prisma-schema/data-model/models#type-modifiers) relation field which is _not_ annotated with `@relation`
+- the [annotated relation field](/orm/prisma-schema/data-model/relations#annotated-relation-fields) (including its relation scalar)
The annotated relation field and relation scalar of a 1-n relation can either _both_ be optional, or _both_ be mandatory. On the other side of the relation, the list is **always mandatory**.
diff --git a/content/200-concepts/100-components/01-prisma-schema/06-relations/300-many-to-many-relations.mdx b/content/200-orm/100-prisma-schema/20-data-model/20-relations/300-many-to-many-relations.mdx
similarity index 88%
rename from content/200-concepts/100-components/01-prisma-schema/06-relations/300-many-to-many-relations.mdx
rename to content/200-orm/100-prisma-schema/20-data-model/20-relations/300-many-to-many-relations.mdx
index 362c31b8b4..89499c2ab9 100644
--- a/content/200-concepts/100-components/01-prisma-schema/06-relations/300-many-to-many-relations.mdx
+++ b/content/200-orm/100-prisma-schema/20-data-model/20-relations/300-many-to-many-relations.mdx
@@ -14,7 +14,7 @@ Prisma schema syntax and the implementation in the underlying database differs b
## Relational databases
-In relational databases, m-n-relations are typically modelled via [relation tables](/concepts/components/prisma-schema/relations/many-to-many-relations#relation-tables). m-n-relations can be either [explicit](#explicit-many-to-many-relations) or [implicit](#implicit-many-to-many-relations) in the Prisma schema. We recommend using [implicit](#implicit-many-to-many-relations) m-n-relations if you do not need to store any additional meta-data in the relation table itself. You can always migrate to an [explicit](#explicit-many-to-many-relations) m-n-relation later if needed.
+In relational databases, m-n-relations are typically modelled via [relation tables](/orm/prisma-schema/data-model/relations/many-to-many-relations#relation-tables). m-n-relations can be either [explicit](#explicit-many-to-many-relations) or [implicit](#implicit-many-to-many-relations) in the Prisma schema. We recommend using [implicit](#implicit-many-to-many-relations) m-n-relations if you do not need to store any additional meta-data in the relation table itself. You can always migrate to an [explicit](#explicit-many-to-many-relations) m-n-relation later if needed.
### Explicit many-to-many relations
@@ -84,7 +84,7 @@ ALTER TABLE "CategoriesOnPosts" ADD CONSTRAINT "CategoriesOnPosts_categoryId_fke
Note that the same rules as for [1-n relations](one-to-many-relations) apply (because `Post`↔ `CategoriesOnPosts` and `Category` ↔ `CategoriesOnPosts` are both in fact 1-n relations), which means one side of the relation needs to be annotated with the `@relation` attribute.
-When you don't need to attach additional information to the relation, you can model m-n-relations as [implicit m-n-relations](#implicit-many-to-many-relations). If you're not using Prisma Migrate but obtain your data model from [introspection](/concepts/components/introspection), you can still make use of implicit m-n-relations by following Prisma's [conventions for relation tables](#conventions-for-relation-tables-in-implicit-m-n-relations).
+When you don't need to attach additional information to the relation, you can model m-n-relations as [implicit m-n-relations](#implicit-many-to-many-relations). If you're not using Prisma Migrate but obtain your data model from [introspection](/orm/prisma-schema/introspection), you can still make use of implicit m-n-relations by following Prisma's [conventions for relation tables](#conventions-for-relation-tables-in-implicit-m-n-relations).
#### Querying an explicit many-to-many
@@ -240,7 +240,7 @@ const getAssignments = await prisma.categoriesOnPosts.findMany({
Implicit m-n relations define relation fields as lists on both sides of the relation. Although the relation table exists in the underlying database, **it is managed by Prisma and does not manifest in the Prisma schema**. Implicit relation tables follow a [specific convention](#conventions-for-relation-tables-in-implicit-m-n-relations).
-Implicit m-n-relations makes the [Prisma Client API](/concepts/components/prisma-client) for m-n-relations a bit simpler (since you have one fewer level of nesting inside of [nested writes](/concepts/components/prisma-client/relation-queries#nested-writes)).
+Implicit m-n-relations makes the [Prisma Client API](/orm/prisma-client) for m-n-relations a bit simpler (since you have one fewer level of nesting inside of [nested writes](/orm/prisma-client/queries/relation-queries#nested-writes)).
In the example below, there's one _implicit_ m-n-relation between `Post` and `Category`:
@@ -333,11 +333,11 @@ const getPostsAndCategories = await prisma.post.findMany({
Implicit m-n relations:
- Use a specific [convention for relation tables](#conventions-for-relation-tables-in-implicit-m-n-relations)
-- Do **not** require the `@relation` attribute unless you need to [disambiguate relations](/concepts/components/prisma-schema/relations#disambiguating-relations) with a name, e.g. `@relation("MyRelation")` or `@relation(name: "MyRelation")`.
+- Do **not** require the `@relation` attribute unless you need to [disambiguate relations](/orm/prisma-schema/data-model/relations#disambiguating-relations) with a name, e.g. `@relation("MyRelation")` or `@relation(name: "MyRelation")`.
- If you do use the `@relation` attribute, you cannot use the `references`, `fields`, `onUpdate` or `onDelete` arguments. This is because these take a fixed value for implicit m-n-relations and cannot be changed.
- Require both models to have a single `@id`. Be aware that:
- - You cannot use a [multi-field ID](/reference/api-reference/prisma-schema-reference#id-1)
+ - You cannot use a [multi-field ID](/orm/reference/prisma-schema-reference#id-1)
- You cannot use a `@unique` in place of an `@id`
@@ -348,7 +348,7 @@ Implicit m-n relations:
#### Conventions for relation tables in implicit m-n relations
-If you obtain your data model from [introspection](/concepts/components/introspection), you can still use implicit m-n-relations by following Prisma's [conventions for relation tables](#conventions-for-relation-tables-in-implicit-m-n-relations). The following example assumes you want to create a relation table to get an implicit m-n-relation for two models called `Post` and `Category`.
+If you obtain your data model from [introspection](/orm/prisma-schema/introspection), you can still use implicit m-n-relations by following Prisma's [conventions for relation tables](#conventions-for-relation-tables-in-implicit-m-n-relations). The following example assumes you want to create a relation table to get an implicit m-n-relation for two models called `Post` and `Category`.
##### Relation table
@@ -365,7 +365,7 @@ When creating an implicit m-n-relation yourself in the Prisma schema file, you c
###### Multi-schema
-If your implicit many-to-many relationship spans multiple database schemas (using the [`multiSchema` preview feature](/guides/database/multi-schema)), the relation table (with the name defined directly above, in the example `_CategoryToPost`) must be present in the same database schema as the first model in alphabetical order (in this case `Category`).
+If your implicit many-to-many relationship spans multiple database schemas (using the [`multiSchema` preview feature](/orm/prisma-schema/data-model/multi-schema)), the relation table (with the name defined directly above, in the example `_CategoryToPost`) must be present in the same database schema as the first model in alphabetical order (in this case `Category`).
##### Columns
@@ -509,9 +509,9 @@ Prisma validates m-n-relations in MongoDB with the following rules:
- The `fields` argument must have only one scalar field defined, which must be of a list type
- The `references` argument must have only one scalar field defined. This scalar field must exist on the referenced model and must be of the same type as the scalar field in the `fields` argument, but singular (no list)
- The scalar field to which `references` points must have the `@id` attribute
-- No [referential actions](/concepts/components/prisma-schema/relations/referential-actions) are allowed in `@relation`
+- No [referential actions](/orm/prisma-schema/data-model/relations/referential-actions) are allowed in `@relation`
-The implicit m-n-relations [used in relational databases](/concepts/components/prisma-schema/relations/many-to-many-relations#implicit-many-to-many-relations) are not supported on MongoDB.
+The implicit m-n-relations [used in relational databases](/orm/prisma-schema/data-model/relations/many-to-many-relations#implicit-many-to-many-relations) are not supported on MongoDB.
### Querying MongoDB many-to-many relations
diff --git a/content/200-concepts/100-components/01-prisma-schema/06-relations/400-self-relations.mdx b/content/200-orm/100-prisma-schema/20-data-model/20-relations/400-self-relations.mdx
similarity index 96%
rename from content/200-concepts/100-components/01-prisma-schema/06-relations/400-self-relations.mdx
rename to content/200-orm/100-prisma-schema/20-data-model/20-relations/400-self-relations.mdx
index dd96c5f621..158e941dc1 100644
--- a/content/200-concepts/100-components/01-prisma-schema/06-relations/400-self-relations.mdx
+++ b/content/200-orm/100-prisma-schema/20-data-model/20-relations/400-self-relations.mdx
@@ -54,7 +54,7 @@ This relation expresses the following:
To create a one-to-one self-relation:
- Both sides of the relation must define a `@relation` attribute that share the same name - in this case, **BlogOwnerHistory**.
-- One relation field must be a [fully annotated](/concepts/components/prisma-schema/relations#relation-fields). In this example, the `successor` field defines both the `field` and `references` arguments.
+- One relation field must be a [fully annotated](/orm/prisma-schema/data-model/relations#relation-fields). In this example, the `successor` field defines both the `field` and `references` arguments.
- One relation field must be backed by a foreign key. The `successor` field is backed by the `successorId` foreign key, which references a value in the `id` field. The `successorId` scalar relation field also requires a `@unique` attribute to guarantee a one-to-one relation.
> **Note**: One-to-one self relations require two sides even if both sides are equal in the relationship. For example, to model a 'best friends' relation, you would need to create two relation fields: `bestfriend1` and a `bestfriend2`.
@@ -223,7 +223,7 @@ This relation expresses the following:
- "a user has zero or one _teachers_ "
- "a user can have zero or more _students_"
-Note that you can also require each user to have a teacher by making the `teacher` field [required](/concepts/components/prisma-schema/data-model#optional-and-mandatory-fields).
+Note that you can also require each user to have a teacher by making the `teacher` field [required](/orm/prisma-schema/data-model/models#optional-and-mandatory-fields).
### One-to-many self-relations in the database
@@ -310,7 +310,7 @@ This relation expresses the following:
- "a user can be followed by zero or more users"
- "a user can follow zero or more users"
-Note that for relational databases, this many-to-many-relation is [implicit](many-to-many-relations#implicit-many-to-many-relations). This means Prisma maintains a [relation table](/concepts/components/prisma-schema/relations/many-to-many-relations#relation-tables) for it in the underlying database.
+Note that for relational databases, this many-to-many-relation is [implicit](many-to-many-relations#implicit-many-to-many-relations). This means Prisma maintains a [relation table](/orm/prisma-schema/data-model/relations/many-to-many-relations#relation-tables) for it in the underlying database.
If you need the relation to hold other fields, you can create an [explicit](many-to-many-relations#explicit-many-to-many-relations) many-to-many self relation as well. The explicit version of the self relation shown previously is as follows:
diff --git a/content/200-concepts/100-components/01-prisma-schema/06-relations/410-referential-actions/100-special-rules-for-referential-actions.mdx b/content/200-orm/100-prisma-schema/20-data-model/20-relations/410-referential-actions/100-special-rules-for-referential-actions.mdx
similarity index 93%
rename from content/200-concepts/100-components/01-prisma-schema/06-relations/410-referential-actions/100-special-rules-for-referential-actions.mdx
rename to content/200-orm/100-prisma-schema/20-data-model/20-relations/410-referential-actions/100-special-rules-for-referential-actions.mdx
index 447fb5cec0..64174bd2c9 100644
--- a/content/200-concepts/100-components/01-prisma-schema/06-relations/410-referential-actions/100-special-rules-for-referential-actions.mdx
+++ b/content/200-orm/100-prisma-schema/20-data-model/20-relations/410-referential-actions/100-special-rules-for-referential-actions.mdx
@@ -9,9 +9,9 @@ tocDepth: 3
Some databases have specific requirements that you should consider if you are using referential actions.
-- Microsoft SQL Server doesn't allow cascading [referential actions](./) on a foreign key, if the relation chain causes a cycle or multiple cascade paths. If the referential actions on the foreign key are set to something other than `NO ACTION` (or `NoAction` if Prisma is managing referential integrity), the server will check for cycles or multiple cascade paths and return an error when executing the SQL.
+- Microsoft SQL Server doesn't allow cascading referential actions on a foreign key, if the relation chain causes a cycle or multiple cascade paths. If the referential actions on the foreign key are set to something other than `NO ACTION` (or `NoAction` if Prisma is managing referential integrity), the server will check for cycles or multiple cascade paths and return an error when executing the SQL.
-- With MongoDB, using referential actions in Prisma requires that for any data model with self-referential relations or cycles between three models, you must set the referential action of `NoAction` to prevent the referential action emulations from looping infinitely. Be aware that by default, the `relationMode = "prisma"` mode is used for MongoDB, which means that Prisma manages [referential integrity](/concepts/components/prisma-schema/relations/relation-mode).
+- With MongoDB, using referential actions in Prisma requires that for any data model with self-referential relations or cycles between three models, you must set the referential action of `NoAction` to prevent the referential action emulations from looping infinitely. Be aware that by default, the `relationMode = "prisma"` mode is used for MongoDB, which means that Prisma manages [referential integrity](/orm/prisma-schema/data-model/relations/relation-mode).
Given the SQL:
@@ -57,7 +57,7 @@ This will result in the following error:
Error parsing attribute "@relation": A self-relation must have `onDelete` and `onUpdate` referential actions set to `NoAction` in one of the @relation attributes. (Implicit default `onDelete`: `SetNull`, and `onUpdate`: `Cascade`)
```
-By not defining any actions, Prisma will use the following default values depending if the underlying [scalar fields](/concepts/components/prisma-schema/data-model#scalar-fields) are set to be optional or required.
+By not defining any actions, Prisma will use the following default values depending if the underlying [scalar fields](/orm/prisma-schema/data-model/models#scalar-fields) are set to be optional or required.
| Clause | All of the scalar fields are optional | At least one scalar field is required |
| :--------- | :------------------------------------ | :------------------------------------ |
diff --git a/content/200-concepts/100-components/01-prisma-schema/06-relations/410-referential-actions/index.mdx b/content/200-orm/100-prisma-schema/20-data-model/20-relations/410-referential-actions/index.mdx
similarity index 80%
rename from content/200-concepts/100-components/01-prisma-schema/06-relations/410-referential-actions/index.mdx
rename to content/200-orm/100-prisma-schema/20-data-model/20-relations/410-referential-actions/index.mdx
index 91b12e2e96..df02fa24e0 100644
--- a/content/200-concepts/100-components/01-prisma-schema/06-relations/410-referential-actions/index.mdx
+++ b/content/200-orm/100-prisma-schema/20-data-model/20-relations/410-referential-actions/index.mdx
@@ -16,7 +16,7 @@ From version 2.26.0, you can define referential actions on the relation fields i
**Version differences**
- If you use version 3.0.1 or later, you can use referential actions as described on this page.
-- If you use a version between 2.26.0 and 3.0.0, you can use referential actions as described on this page, but you must [enable the preview feature flag](/concepts/components/preview-features/client-preview-features#enabling-a-prisma-client-preview-feature) `referentialActions`.
+- If you use a version between 2.26.0 and 3.0.0, you can use referential actions as described on this page, but you must [enable the preview feature flag](/orm/reference/preview-features/client-preview-features#enabling-a-prisma-client-preview-feature) `referentialActions`.
- If you use version 2.25.0 or earlier, you can configure cascading deletes manually in your database.
@@ -44,19 +44,19 @@ If you do not specify a referential action, Prisma [uses a default](#referential
If you upgrade from a version earlier than 2.26.0:
-It is extremely important that you check the [upgrade paths for referential actions](/guides/upgrade-guides/upgrading-versions/upgrading-to-prisma-3/referential-actions) section. Prisma support of referential actions **removes the safety net in Prisma Client that prevents cascading deletes at runtime**. If you use the feature _without upgrading your database_, the [old default action](/guides/upgrade-guides/upgrading-versions/upgrading-to-prisma-3/referential-actions#prisma-2x-default-referential-actions) - `ON DELETE CASCADE` - becomes active. This might result in cascading deletes that you did not expect.
+It is extremely important that you check the [upgrade paths for referential actions](/orm/more/upgrade-guides/upgrading-versions/upgrading-to-prisma-3/referential-actions) section. Prisma support of referential actions **removes the safety net in Prisma Client that prevents cascading deletes at runtime**. If you use the feature _without upgrading your database_, the [old default action](/orm/more/upgrade-guides/upgrading-versions/upgrading-to-prisma-3/referential-actions#prisma-2x-default-referential-actions) - `ON DELETE CASCADE` - becomes active. This might result in cascading deletes that you did not expect.
## What are referential actions?
-Referential actions are policies that define how a referenced record is handled by the database when you run an [`update`](/concepts/components/prisma-client/crud#update) or [`delete`](/concepts/components/prisma-client/crud#delete) query.
+Referential actions are policies that define how a referenced record is handled by the database when you run an [`update`](/orm/prisma-client/queries/crud#update) or [`delete`](/orm/prisma-client/queries/crud#delete) query.
Referential actions on the database level
Referential actions are features of foreign key constraints that exist to preserve referential integrity in your database.
-When you define relationships between data models in your Prisma schema, you use [relation fields](/concepts/components/prisma-schema/relations#relation-fields), **which do not exist on the database**, and [scalar fields](/concepts/components/prisma-schema/data-model#scalar-fields), **which do exist on the database**. These foreign keys connect the models on the database level.
+When you define relationships between data models in your Prisma schema, you use [relation fields](/orm/prisma-schema/data-model/relations#relation-fields), **which do not exist on the database**, and [scalar fields](/orm/prisma-schema/data-model/models#scalar-fields), **which do exist on the database**. These foreign keys connect the models on the database level.
Referential integrity states that these foreign keys must reference an existing primary key value in the related database table. In your Prisma schema, this is generally represented by the `id` field on the related model.
@@ -66,7 +66,7 @@ By default a database will reject any operation that violates the referential in
### How to use referential actions
-Referential actions are defined in the [`@relation`](/reference/api-reference/prisma-schema-reference#relation) attribute and map to the actions on the **foreign key constraint** in the underlying database. If you do not specify a referential action, [Prisma falls back to a default](#referential-action-defaults).
+Referential actions are defined in the [`@relation`](/orm/reference/prisma-schema-reference#relation) attribute and map to the actions on the **foreign key constraint** in the underlying database. If you do not specify a referential action, [Prisma falls back to a default](#referential-action-defaults).
The following model defines a one-to-many relation between `User` and `Post` and a many-to-many relation between `Post` and `Tag`, with explicitly defined referential actions:
@@ -143,7 +143,7 @@ The schema does not explicitly define referential actions on the mandatory `auth
The following caveats apply:
-- Referential actions are **not** supported on [implicit many-to-many relations](/concepts/components/prisma-schema/relations/many-to-many-relations#implicit-many-to-many-relations). To use referential actions, you must define an explicit many-to-many relation and define your referential actions on the [join table](/concepts/components/prisma-schema/relations/troubleshooting-relations#how-to-use-a-relation-table-with-a-many-to-many-relationship).
+- Referential actions are **not** supported on [implicit many-to-many relations](/orm/prisma-schema/data-model/relations/many-to-many-relations#implicit-many-to-many-relations). To use referential actions, you must define an explicit many-to-many relation and define your referential actions on the [join table](/orm/prisma-schema/data-model/relations/troubleshooting-relations#how-to-use-a-relation-table-with-a-many-to-many-relationship).
- Certain combinations of referential actions and required/optional relations are incompatible. For example, using `SetNull` on a required relation will lead to database errors when deleting referenced records because the non-nullable constraint would be violated. See [this GitHub issue](https://github.com/prisma/prisma/issues/7909) for more information.
## Types of referential actions
@@ -153,12 +153,11 @@ The following table shows which referential action each database supports.
| Database | Cascade | Restrict | NoAction | SetNull | SetDefault |
| :---------- | :------ | :------- | :------- | :------ | :--------- |
| PostgreSQL | ✔️ | ✔️ | ✔️ | ✔️⌘ | ✔️ |
-| MySQL | ✔️ | ✔️ | ✔️ | ✔️ | ❌ (✔️†) |
+| MySQL | ✔️ | ✔️ | ✔️ | ✔️ | ❌ (✔️†) |
| SQLite | ✔️ | ✔️ | ✔️ | ✔️ | ✔️ |
-| SQL Server | ✔️ | ❌‡ | ✔️ | ✔️ | ✔️ |
+| SQL Server | ✔️ | ❌‡ | ✔️ | ✔️ | ✔️ |
| CockroachDB | ✔️ | ✔️ | ✔️ | ✔️ | ✔️ |
-| MongoDB†† | ✔️ | ✔️ | ✔️ | ✔️ | ❌ |
-
+| MongoDB†† | ✔️ | ✔️ | ✔️ | ✔️ | ❌ |
- † See [special cases for MySQL](#mysql).
- ⌘ See [special cases for PostgreSQL](#postgresql).
@@ -254,7 +253,7 @@ model User {
-The `Restrict` action is **not** available on [Microsoft SQL Server](/concepts/database-connectors/sql-server) and triggers a schema validation error. Instead, you can use [`NoAction`](#noaction), which produces the same result and is compatible with SQL Server.
+The `Restrict` action is **not** available on [Microsoft SQL Server](/orm/overview/databases/sql-server) and triggers a schema validation error. Instead, you can use [`NoAction`](#noaction), which produces the same result and is compatible with SQL Server.
@@ -270,7 +269,7 @@ The `NoAction` action is similar to `Restrict`, the difference between the two i
-If you are [managing relations in Prisma Client](/concepts/components/prisma-schema/relations/relation-mode#emulate-relations-in-prisma-with-the-prisma-relation-mode) rather than using foreign keys in the database, you should be aware that currently Prisma only implements the referential actions. Foreign keys also create constraints, which make it impossible to manipulate data in a way that would violate these constraints: instead of executing the query, the database responds with an error. These constraints will not be created if you emulate referential integrity in Prisma Client, so if you set the referential action to `NoAction` there will be no checks to prevent you from breaking the referential integrity.
+If you are [managing relations in Prisma Client](/orm/prisma-schema/data-model/relations/relation-mode#emulate-relations-in-prisma-with-the-prisma-relation-mode) rather than using foreign keys in the database, you should be aware that currently Prisma only implements the referential actions. Foreign keys also create constraints, which make it impossible to manipulate data in a way that would violate these constraints: instead of executing the query, the database responds with an error. These constraints will not be created if you emulate referential integrity in Prisma Client, so if you set the referential action to `NoAction` there will be no checks to prevent you from breaking the referential integrity.
@@ -328,7 +327,7 @@ When changing a `User`'s `id`, the `authorId` will be set to `NULL` for all its
- `onUpdate: SetDefault` The scalar field of the referencing object will be set to the fields default value.
-These require setting a default for the relation scalar field with [`@default`](/reference/api-reference/prisma-schema-reference#default). If no defaults are provided for any of the scalar fields, a runtime error will be thrown.
+These require setting a default for the relation scalar field with [`@default`](/orm/reference/prisma-schema-reference#default). If no defaults are provided for any of the scalar fields, a runtime error will be thrown.
```prisma file=schema.prisma highlight=4,5;add
model Post {
@@ -352,7 +351,7 @@ When the `username` of a `User` changes, its existing posts' `authorUsername` fi
### Database-specific requirements
-MongoDB and SQL Server have specific requirements for referential actions if you have [self-relations](/concepts/components/prisma-schema/relations/referential-actions/special-rules-for-referential-actions#self-relation-sql-server-and-mongodb) or [cyclic relations](/concepts/components/prisma-schema/relations/referential-actions/special-rules-for-referential-actions#cyclic-relation-between-three-tables-sql-server-and-mongodb) in your data model. SQL Server also has specific requirements if you have relations with [multiple cascade paths](/concepts/components/prisma-schema/relations/referential-actions/special-rules-for-referential-actions#multiple-cascade-paths-between-two-models-sql-server-only).
+MongoDB and SQL Server have specific requirements for referential actions if you have [self-relations](/orm/prisma-schema/data-model/relations/referential-actions/special-rules-for-referential-actions#self-relation-sql-server-and-mongodb) or [cyclic relations](/orm/prisma-schema/data-model/relations/referential-actions/special-rules-for-referential-actions#cyclic-relation-between-three-tables-sql-server-and-mongodb) in your data model. SQL Server also has specific requirements if you have relations with [multiple cascade paths](/orm/prisma-schema/data-model/relations/referential-actions/special-rules-for-referential-actions#multiple-cascade-paths-between-two-models-sql-server-only).
## Upgrade paths from versions 2.25.0 and earlier
@@ -366,7 +365,7 @@ The following assumes you have upgraded to 2.26.0 or newer and enabled the previ
### Using Introspection
-If you [Introspect](../../../introspection) your database, the referential actions configured at the database level will be reflected in your Prisma Schema. If you have been using Prisma Migrate or `prisma db push` to manage the database schema, these are likely to be the [default values](#the-default-referential-actions) from 2.25.0 and earlier.
+If you [Introspect](/orm/prisma-schema/introspection) your database, the referential actions configured at the database level will be reflected in your Prisma Schema. If you have been using Prisma Migrate or `prisma db push` to manage the database schema, these are likely to be the [default values](#referential-action-defaults) from 2.25.0 and earlier.
When you run an Introspection, Prisma compares all the foreign keys in the database with the schema, if the SQL statements `ON DELETE` and `ON UPDATE` do **not** match the default values, they will be explicitly set in the schema file.
@@ -374,7 +373,7 @@ After introspecting, you can review the non-default clauses in your schema. The
-If you are using either the [`delete()`](../../../prisma-client/crud#delete-a-single-record) or [`deleteMany()`](../../../prisma-client/crud#delete-all-records) methods, **[cascading deletes](#how-to-use-cascading-deletes) will now be performed** as the `referentialActions` preview feature **removed the safety net in Prisma Client that previously prevented cascading deletes at runtime**. Be sure to check your code and make any adjustments accordingly.
+If you are using either the [`delete()`](/orm/prisma-client/queries/crud#delete-a-single-record) or [`deleteMany()`](/orm/prisma-client/queries/crud#delete-all-records) methods, **[cascading deletes](#how-to-use-cascading-deletes) will now be performed** as the `referentialActions` preview feature **removed the safety net in Prisma Client that previously prevented cascading deletes at runtime**. Be sure to check your code and make any adjustments accordingly.
@@ -406,7 +405,7 @@ model User {
### Using Migration
-When running a [Migration](../../../prisma-migrate) (or the [`prisma db push`](../../../prisma-migrate/db-push) command) the [new defaults](#referential-action-defaults) will be applied to your database.
+When running a [Migration](/orm/prisma-migrate) (or the [`prisma db push`](/orm/prisma-migrate/workflows/prototyping-your-schema) command) the [new defaults](#referential-action-defaults) will be applied to your database.
diff --git a/content/200-concepts/100-components/01-prisma-schema/06-relations/420-relation-mode.mdx b/content/200-orm/100-prisma-schema/20-data-model/20-relations/420-relation-mode.mdx
similarity index 85%
rename from content/200-concepts/100-components/01-prisma-schema/06-relations/420-relation-mode.mdx
rename to content/200-orm/100-prisma-schema/20-data-model/20-relations/420-relation-mode.mdx
index e0cb298df6..8ff4964b82 100644
--- a/content/200-concepts/100-components/01-prisma-schema/06-relations/420-relation-mode.mdx
+++ b/content/200-orm/100-prisma-schema/20-data-model/20-relations/420-relation-mode.mdx
@@ -7,7 +7,7 @@ tocDepth: 3
-In Prisma, relations between records are defined with the [`@relation`](/reference/api-reference/prisma-schema-reference#relation) attribute. For example, in the following schema there is a one-to-many relation between the `User` and `Post` models:
+In Prisma, relations between records are defined with the [`@relation`](/orm/reference/prisma-schema-reference#relation) attribute. For example, in the following schema there is a one-to-many relation between the `User` and `Post` models:
```prisma file=schema.prisma highlight=4,5,10;normal
model Post {
@@ -28,7 +28,7 @@ Prisma has two _relation modes_, `foreignKeys` and `prisma`, that specify how re
If you use Prisma with a relational database, then by default Prisma uses the [`foreignKeys` relation mode](#handle-relations-in-your-relational-database-with-the-foreignkeys-relation-mode), which enforces relations between records at the database level with foreign keys. A foreign key is a column or group of columns in one table that take values based on the primary key in another table. Foreign keys allow you to:
- set constraints that prevent you from making changes that break references
-- set [referential actions](/concepts/components/prisma-schema/relations/referential-actions) that define how changes to records are handled
+- set [referential actions](/orm/prisma-schema/data-model/relations/referential-actions) that define how changes to records are handled
Together these constraints and referential actions guarantee the _referential integrity_ of the data.
@@ -61,7 +61,7 @@ ALTER TABLE "Post"
In this case, the foreign key constraint on the `authorId` column of the `Post` table references the `id` column of the `User` table, and guarantees that a post must have an author that exists. If you update or delete a user then the `ON DELETE` and `ON UPDATE` referential actions specify the `CASCADE` option, which will also delete or update all posts belonging to the user.
-Some databases, such as MongoDB or [PlanetScale](/guides/database/planetscale#differences-to-consider), do not support foreign keys. Additionally, in some cases developers may prefer not to use foreign keys in their relational database that usually does support foreign keys. For these situations, Prisma offers [the `prisma` relation mode](#emulate-relations-in-prisma-with-the-prisma-relation-mode), which emulates some properties of relations in relational databases. When you use Prisma Client with the `prisma` relation mode enabled, the behavior of queries is identical or similar, but referential actions and some constraints are handled by the Prisma engine rather than in the database.
+Some databases, such as MongoDB or [PlanetScale](/orm/overview/databases/planetscale#differences-to-consider), do not support foreign keys. Additionally, in some cases developers may prefer not to use foreign keys in their relational database that usually does support foreign keys. For these situations, Prisma offers [the `prisma` relation mode](#emulate-relations-in-prisma-with-the-prisma-relation-mode), which emulates some properties of relations in relational databases. When you use Prisma Client with the `prisma` relation mode enabled, the behavior of queries is identical or similar, but referential actions and some constraints are handled by the Prisma engine rather than in the database.
There are performance implications to emulation of referential integrity and
@@ -92,7 +92,7 @@ The ability to set the relation mode was introduced as part of the `referentialI
For relational databases, the available options are:
- `foreignKeys`: this handles relations in the database with foreign keys. This is the default option for all relational database connectors and is active if no `relationMode` is explicitly set in the `datasource` block.
-- `prisma`: this emulates relations in Prisma Client. You should also [enable this option](/guides/database/planetscale#how-to-emulate-relations-in-prisma-client) when you use the MySQL connector with a PlanetScale database.
+- `prisma`: this emulates relations in Prisma Client. You should also [enable this option](/orm/overview/databases/planetscale#how-to-emulate-relations-in-prisma-client) when you use the MySQL connector with a PlanetScale database.
For MongoDB, the only available option is the `prisma` relation mode. This mode is also active if no `relationMode` is explicitly set in the `datasource` block.
@@ -106,7 +106,7 @@ If you switch between relation modes, Prisma will add or remove foreign keys to
The `foreignKeys` relation mode handles relations in your relational database with foreign keys. This is the default option when you use a relational database connector (PostgreSQL, MySQL, SQLite, SQL Server, CockroachDB).
-The `foreignKeys` relation mode is not available when you use the MongoDB connector. Some relational databases, [such as PlanetScale](/guides/database/planetscale#how-to-emulate-relations-in-prisma-client), also forbid the use of foreign keys. In these cases, you should instead [emulate relations in Prisma with the `prisma` relation mode](#emulate-relations-in-prisma-with-the-prisma-relation-mode).
+The `foreignKeys` relation mode is not available when you use the MongoDB connector. Some relational databases, [such as PlanetScale](/orm/overview/databases/planetscale#how-to-emulate-relations-in-prisma-client), also forbid the use of foreign keys. In these cases, you should instead [emulate relations in Prisma with the `prisma` relation mode](#emulate-relations-in-prisma-with-the-prisma-relation-mode).
### Referential integrity
@@ -120,7 +120,7 @@ When you _create_ or _update_ a record with a relation to another record, the re
When you _update_ or _delete_ a record with a relation to another record, referential actions are triggered in the database. To maintain referential integrity in related records, referential actions prevent changes that would break referential integrity, cascade changes through to related records, or set the value of fields that reference the updated or deleted records to a `null` or default value.
-For more information, see the [referential actions](/concepts/components/prisma-schema/relations/referential-actions) page.
+For more information, see the [referential actions](/orm/prisma-schema/data-model/relations/referential-actions) page.
### Introspection
@@ -134,7 +134,7 @@ When you apply changes to your Prisma schema with Prisma Migrate or `db push` wi
The `prisma` relation mode emulates some foreign key constraints and referential actions for each Prisma Client query to maintain referential integrity, using some additional database queries and logic.
-The `prisma` relation mode is the default option for the MongoDB connector. It should also be set if you use a relational database that does not support foreign keys. For example, [if you use PlanetScale](/guides/database/planetscale#how-to-emulate-relations-in-prisma-client) you should use the `prisma` relation mode.
+The `prisma` relation mode is the default option for the MongoDB connector. It should also be set if you use a relational database that does not support foreign keys. For example, [if you use PlanetScale](/orm/overview/databases/planetscale#how-to-emulate-relations-in-prisma-client) you should use the `prisma` relation mode.
There are performance implications to emulation of referential integrity in
@@ -195,7 +195,7 @@ When you apply changes to your Prisma schema with Prisma Migrate or `db push` wi
In relational databases that use foreign key constraints, the database usually also implicitly creates an index for the foreign key columns. For example, [MySQL will create an index on all foreign key columns](https://dev.mysql.com/doc/refman/8.0/en/constraint-foreign-key.html#:~:text=MySQL%20requires%20that%20foreign%20key%20columns%20be%20indexed%3B%20if%20you%20create%20a%20table%20with%20a%20foreign%20key%20constraint%20but%20no%20index%20on%20a%20given%20column%2C%20an%20index%20is%20created.). This is to allow foreign key checks to run fast and not require a table scan.
-The `prisma` relation mode does not use foreign keys, so no indexes are created when you use Prisma Migrate or `db push` to apply changes to your database. You instead need to manually add an index on your relation scalar fields with the [`@@index`](/reference/api-reference/prisma-schema-reference#index) attribute (or the [`@unique`](/reference/api-reference/prisma-schema-reference#unique), [`@@unique`](/reference/api-reference/prisma-schema-reference#unique-1) or [`@@id`](/reference/api-reference/prisma-schema-reference#id-1) attributes, if applicable).
+The `prisma` relation mode does not use foreign keys, so no indexes are created when you use Prisma Migrate or `db push` to apply changes to your database. You instead need to manually add an index on your relation scalar fields with the [`@@index`](/orm/reference/prisma-schema-reference#index) attribute (or the [`@unique`](/orm/reference/prisma-schema-reference#unique), [`@@unique`](/orm/reference/prisma-schema-reference#unique-1) or [`@@id`](/orm/reference/prisma-schema-reference#id-1) attributes, if applicable).
#### Index validation
@@ -238,7 +238,7 @@ model Post {
}
```
-If you use the [Prisma VS Code extension](https://marketplace.visualstudio.com/items?itemName=Prisma.prisma) (or our [language server in another editor](/guides/development-environment/editor-setup)), the warning is augmented with a Quick Fix that adds the required index for you:
+If you use the [Prisma VS Code extension](https://marketplace.visualstudio.com/items?itemName=Prisma.prisma) (or our [language server in another editor](/orm/more/development-environment/editor-setup)), the warning is augmented with a Quick Fix that adds the required index for you:
@@ -252,7 +252,7 @@ The default relation mode if you use a relational database and do not include th
When you switch the relation mode from `foreignKeys` to `prisma`, after you first apply changes to your schema with Prisma Migrate or `db push` Prisma will remove all previously created foreign keys in the next migration.
-If you keep the same database, you can then continue to work as normal. If you switch to a database that does not support foreign keys at all, your existing migration history contains SQL DDL that creates foreign keys, which might trigger errors if you ever have to rerun these migrations. In this case, we recommend that you delete the `migrations` directory. (If you use PlanetScale, which does not support foreign keys, we generally recommend that you [use `db push` rather than Prisma Migrate](/guides/database/planetscale#differences-to-consider).)
+If you keep the same database, you can then continue to work as normal. If you switch to a database that does not support foreign keys at all, your existing migration history contains SQL DDL that creates foreign keys, which might trigger errors if you ever have to rerun these migrations. In this case, we recommend that you delete the `migrations` directory. (If you use PlanetScale, which does not support foreign keys, we generally recommend that you [use `db push` rather than Prisma Migrate](/orm/overview/databases/planetscale#differences-to-consider).)
### Switch from prisma to foreignKeys
diff --git a/content/200-concepts/100-components/01-prisma-schema/06-relations/500-troubleshooting-relations.mdx b/content/200-orm/100-prisma-schema/20-data-model/20-relations/500-troubleshooting-relations.mdx
similarity index 92%
rename from content/200-concepts/100-components/01-prisma-schema/06-relations/500-troubleshooting-relations.mdx
rename to content/200-orm/100-prisma-schema/20-data-model/20-relations/500-troubleshooting-relations.mdx
index 9828114096..82ebbcc5e2 100644
--- a/content/200-concepts/100-components/01-prisma-schema/06-relations/500-troubleshooting-relations.mdx
+++ b/content/200-orm/100-prisma-schema/20-data-model/20-relations/500-troubleshooting-relations.mdx
@@ -224,7 +224,7 @@ model Category {
}
```
-This however tells Prisma to expect **two** separate one-to-many relationships. See [disambiguating relations](/concepts/components/prisma-schema/relations#disambiguating-relations) for more information on using the `@relation` attribute.
+This however tells Prisma to expect **two** separate one-to-many relationships. See [disambiguating relations](/orm/prisma-schema/data-model/relations#disambiguating-relations) for more information on using the `@relation` attribute.
The following example is the correct way to define an implicit many-to-many relationship.
@@ -244,7 +244,7 @@ model Category {
}
```
-The `@relation` annotation can also be used to [name the underlying relation table](/concepts/components/prisma-schema/relations/many-to-many-relations#configuring-the-name-of-the-relation-table-in-implicit-many-to-many-relations) created on a implicit many-to-many relationship.
+The `@relation` annotation can also be used to [name the underlying relation table](/orm/prisma-schema/data-model/relations/many-to-many-relations#configuring-the-name-of-the-relation-table-in-implicit-many-to-many-relations) created on a implicit many-to-many relationship.
```prisma
model Post {
@@ -268,4 +268,4 @@ Some cloud providers enforce the existence of primary keys in all tables. Howeve
### Solution
-You need to use [explicit relation syntax](/concepts/components/prisma-schema/relations/many-to-many-relations#explicit-many-to-many-relations), manually create the join model, and verify that this join model has a primary key.
+You need to use [explicit relation syntax](/orm/prisma-schema/data-model/relations/many-to-many-relations#explicit-many-to-many-relations), manually create the join model, and verify that this join model has a primary key.
diff --git a/content/200-concepts/100-components/01-prisma-schema/06-relations/index.mdx b/content/200-orm/100-prisma-schema/20-data-model/20-relations/index.mdx
similarity index 87%
rename from content/200-concepts/100-components/01-prisma-schema/06-relations/index.mdx
rename to content/200-orm/100-prisma-schema/20-data-model/20-relations/index.mdx
index 6c7441ca57..ad763bce79 100644
--- a/content/200-concepts/100-components/01-prisma-schema/06-relations/index.mdx
+++ b/content/200-orm/100-prisma-schema/20-data-model/20-relations/index.mdx
@@ -53,7 +53,6 @@ At a Prisma level, the `User` / `Post` relation is made up of:
At a Prisma level, a connection between two models is **always** represented by a [relation field](#relation-fields) on **each side** of the relation.
-