メインコンテンツにスキップ

Prisma Client APIリファレンス

Prisma Client APIリファレンスドキュメントは、次のスキーマに基づいています。

model User {
  id           Int              @id @default(autoincrement())
  name         String?
  email        String           @unique
  profileViews Int              @default(0)
  role         Role             @default(USER)
  coinflips    Boolean[]
  posts        Post[]
  city         String
  country      String
  profile      ExtendedProfile?
  pets         Json
}

model ExtendedProfile {
  id     Int     @id @default(autoincrement())
  userId Int?    @unique
  bio    String?
  User   User?   @relation(fields: [userId], references: [id])
}

model Post {
  id        Int     @id @default(autoincrement())
  title     String
  published Boolean @default(true)
  author    User    @relation(fields: [authorId], references: [id])
  authorId  Int
  comments  Json
  views     Int     @default(0)
  likes     Int     @default(0)
}

enum Role {
  USER
  ADMIN
}

すべての例で生成される型（UserSelectやUserWhereUniqueInputなど）は、Userモデルに基づいています。

PrismaClient​

このセクションでは、PrismaClientコンストラクタとそのパラメータについて説明します。

備考​

  • パラメータは実行時に検証されます。

datasources​

schema.prismaファイルのdatasourceブロックのプロパティをプログラムでオーバーライドします。たとえば、統合テストの一部として使用します。こちらも参照してください：データソース

バージョン5.2.0以降では、datasourceUrlプロパティを使用して、データベース接続文字列をプログラムでオーバーライドすることもできます。

プロパティ​

プロパティの例値の例説明
db{ url: 'file:./dev_qa.db' }データベースの接続URL。

備考​

  • データソースを追加または名前変更するたびに、Prisma Clientを再生成する必要があります。データソース名は、生成されたクライアントに含まれています。
  • スキーマでdatasourceブロックに別の名前を付けた場合は、dbをdatasourceブロックの名前に置き換えてください。

例​

データソースのurlをプログラムでオーバーライドする​
import { PrismaClient } from '@prisma/client';

const prisma = new PrismaClient({
  datasources: {
    db: {
      url: 'file:./dev_qa.db',
    },
  },
});

次のdatasourceブロックに基づく

datasource db {
  provider = "sqlite"
  url      = env("DATABASE_URL")
}

datasourceUrl​

schema.prismaファイルのdatasourceブロックをプログラムでオーバーライドします。

プロパティ​

オプション値の例説明
データベース接続文字列'file:./dev_qa.db'データベースの接続URL。

例​

import { PrismaClient } from '@prisma/client';

const prisma = new PrismaClient({
  datasourceUrl: 'postgresql://johndoe:randompassword@localhost:5432/mydb',
});

log​

ロギングの種類とレベルを決定します。こちらも参照してください：ロギング

オプション​

オプション例
ログレベルの配列[ "info", "query" ]
ログ定義の配列[ { level: "info", emit: "event" }, { level: "warn", emit: "stdout" }]
ログレベル​
名前例
queryPrismaによって実行されるすべてのクエリをログに記録します。

リレーショナルデータベースの場合、これはすべてのSQLクエリをログに記録します。例
prisma:query SELECT "public"."User"."id", "public"."User"."email" FROM "public"."User" WHERE ("public"."User"."id") IN (SELECT "t0"."id" FROM "public"."User" AS "t0" INNER JOIN "public"."Post" AS "j0" ON ("j0"."authorId") = ("t0"."id") WHERE ("j0"."views" > $1 AND "t0"."id" IS NOT NULL)) OFFSET $2

MongoDBの場合、これはmongoshシェル形式を使用してクエリをログに記録します。例
prisma:query db.User.deleteMany({ _id: ( $in: [ “6221ce49f756b0721fc00542”, ], }, })
info例
prisma:info http://127.0.0.1:58471でhttpサーバーを開始しました
warn警告。
errorエラー。
出力形式​
名前説明
stdout参照：stdout
eventサブスクライブできるイベントを発生させます。
イベントタイプ​

queryイベントタイプ

index.d.ts
export type QueryEvent = {
  timestamp: Date;
  query: string; // Query sent to the database
  params: string; // Query parameters
  duration: number; // Time elapsed (in milliseconds) between client issuing query and database responding - not only time taken to run query
  target: string;
};

MongoDBの場合、paramsフィールドとdurationフィールドは未定義になることに注意してください。

その他すべてのログレベルイベントタイプ

index.d.ts
export type LogEvent = {
  timestamp: Date;
  message: string;
  target: string;
};

例​

queryとinfoをstdoutにログ出力する​
import { PrismaClient } from '@prisma/client';

const prisma = new PrismaClient({ log: ['query', 'info'] });

async function main() {
  const countUsers = await prisma.user.count({});
}

main()
  .then(async () => {
    await prisma.$disconnect();
  })
  .catch(async (e) => {
    console.error(e);
    await prisma.$disconnect();
    process.exit(1);
  });
表示CLI結果
queryイベントをコンソールにログ出力する​
import { PrismaClient } from '@prisma/client';

const prisma = new PrismaClient({
  log: [{ level: 'query', emit: 'event' }],
});

prisma.$on('query', (e) => {
  console.log(e);
});

async function main() {
  const countUsers = await prisma.user.count({});
}

main()
  .then(async () => {
    await prisma.$disconnect();
  })
  .catch(async (e) => {
    console.error(e);
    await prisma.$disconnect();
    process.exit(1);
  });
表示CLI結果
info、warn、およびerrorイベントをコンソールにログ出力する​
import { PrismaClient } from '@prisma/client';

const prisma = new PrismaClient({
  log: [
    { level: 'warn', emit: 'event' },
    { level: 'info', emit: 'event' },
    { level: 'error', emit: 'event' },
  ],
});

prisma.$on('warn', (e) => {
  console.log(e);
});

prisma.$on('info', (e) => {
  console.log(e);
});

prisma.$on('error', (e) => {
  console.log(e);
});

async function main() {
  const countUsers = await prisma.user.count({});
}

main()
  .then(async () => {
    await prisma.$disconnect();
  })
  .catch(async (e) => {
    console.error(e);
    await prisma.$disconnect();
    process.exit(1);
  });
表示CLI結果

errorFormat​

Prisma Clientによって返されるエラーのレベルとフォーマットを決定します。

エラーフォーマット​

名前説明
undefined定義されていない場合、デフォルトはcolorlessです。
prettyprettyエラーフォーマットを有効にします。
colorless（デフォルト）colorlessエラーフォーマットを有効にします。
minimalminimalエラーフォーマットを有効にします。

例​

エラーフォーマットなし​
const prisma = new PrismaClient({
  // Defaults to colorless
});
prettyエラーフォーマット​
const prisma = new PrismaClient({
  errorFormat: 'pretty',
});
colorlessエラーフォーマット​
const prisma = new PrismaClient({
  errorFormat: 'colorless',
});
minimalエラーフォーマット​
const prisma = new PrismaClient({
  errorFormat: 'minimal',
});

adapter​

ドライバアダプタのインスタンスを定義します。こちらも参照してくださいデータベースドライバ。

情報

これは、バージョン5.4.0以降のdriverAdaptersフィーチャーフラグの背後で利用可能です。

例​

以下の例では、Neonドライバアダプタを使用しています

import { Pool, neonConfig } from '@neondatabase/serverless';
import { PrismaNeon } from '@prisma/adapter-neon';
import { PrismaClient } from '@prisma/client';
import dotenv from 'dotenv';
import ws from 'ws';

dotenv.config();
neonConfig.webSocketConstructor = ws;
const connectionString = `${process.env.DATABASE_URL}`;

const pool = new Pool({ connectionString });
const adapter = new PrismaNeon(pool);
const prisma = new PrismaClient({ adapter });

rejectOnNotFound​

情報

注意：rejectOnNotFoundはv5.0.0で削除されました。

非推奨： rejectOnNotFoundはv4.0.0で非推奨になりました。v4.0.0以降では、クエリfindUniqueOrThrowまたはfindFirstOrThrowを使用してください。

rejectOnNotFoundパラメータを使用して、レコードが見つからなかった場合にエラーをスローするようにfindUnique()および/またはfindFirstを設定します。デフォルトでは、レコードが見つからない場合、両方の操作はnullを返します。

備考​

オプション​

オプション説明
RejectOnNotFoundグローバルに有効にする（true / false）またはカスタムエラーをスローします。
RejectPerOperation操作ごとに有効にする（true / false）またはモデルごと、操作ごとにカスタムエラーをスローします。

例​

findUnique()とfindFirstに対してグローバルに有効にする​
const prisma = new PrismaClient({
  rejectOnNotFound: true,
});
特定の操作に対してグローバルに有効にする​
const prisma = new PrismaClient({
  rejectOnNotFound: {
    findUnique: true,
  },
});
レコードが見つからない場合は、モデルと操作ごとにカスタムエラーをスローする​
const prisma = new PrismaClient({
  rejectOnNotFound: {
    findFirst: {
      User: (err) => new Error('User error'),
      Post: (err) => new Error('Post error!'),
    },
    findUnique: {
      User: (err) => new Error('User error'),
      Post: (err) => new Error('Post error!'),
    },
  },
});

transactionOptions​

情報

注意：transactionOptionsはv5.10.0で導入されました。

コンストラクタレベルでグローバルにトランザクションオプションを設定できます。

備考​

  • トランザクションレベルは、トランザクションごとにオーバーライドできます。

オプション​

オプション説明
maxWaitPrisma Clientがデータベースからトランザクションを取得するまで待機する最大時間。デフォルト値は2秒です。
timeoutインタラクティブトランザクションがキャンセルされてロールバックされるまでに実行できる最大時間。デフォルト値は5秒です。
isolationLevelトランザクション分離レベルを設定します。デフォルトでは、これはデータベースで現在構成されている値に設定されています。利用可能な値は、使用するデータベースによって異なる場合があります。

例​

const prisma = new PrismaClient({
  transactionOptions: {
    isolationLevel: Prisma.TransactionIsolationLevel.Serializable,
    maxWait: 5000, // default: 2000
    timeout: 10000, // default: 5000
  },
});

モデルクエリ​

モデルクエリを使用して、モデルに対してCRUD操作を実行します。こちらも参照してください：CRUD

注意：Prismaクエリに渡す前に、信頼できないユーザーデータを常に検証およびサニタイズすることがベストプラクティスです。そうしないと、型チェックがバイパスされた場合、SQLインジェクションまたはその他のインジェクション脆弱性につながる可能性があります。ユーザーが提供する値が、重要なチェックを誤ってバイパスできないようにしてください。アプリケーションレイヤーで型チェックと入力検証を実行することを強くお勧めします。詳細については、「カスタム検証」セクションを参照してください。

findUnique()​

findUnique()クエリを使用すると、単一のデータベースレコードを取得できます

  • ID別
  • unique属性別

findUnique()は、バージョン2.12.0でfindOneを置き換えました。

備考​

  • Prisma Clientのdataloader findUnique()クエリを自動的にバッチ処理します。selectおよびwhereパラメータが同じ場合。
  • レコードが見つからない場合にクエリがエラーをスローするようにする場合は、代わりにfindUniqueOrThrowの使用を検討してください。
  • フィルター条件（equals、contains、notなど）を使用して、JSONデータ型のフィールドをフィルタリングすることはできません。フィルター条件を使用すると、そのフィールドに対してnullレスポンスが返される可能性があります。

オプション​

名前型例（User）必須説明
whereUserWhereUniqueInputはいレコードを選択できるように、モデルのすべてのフィールドをラップします（詳細はこちら）。
バージョン4.5.0より前では、この型はモデルのuniqueフィールドのみをラップしていました。
selectXOR<UserSelect, null>いいえ返されるオブジェクトに含めるプロパティを指定します。
includeXOR<UserInclude, null>いいえ返されるオブジェクトに遅延ロードする必要があるリレーションを指定します。
omitXOR<UserOmit, null>いいえ返されるオブジェクトから除外するプロパティを指定します。プレビューは5.13.0以降です
relationLoadStrategy'join'または'query'いいえデフォルト：join。リレーションクエリのロード戦略を指定します。include（またはリレーションフィールドのselect）との組み合わせでのみ使用可能です。プレビューは5.9.0以降です。

戻り値の型​

戻り値の型例説明
JavaScriptオブジェクト（型付き）User
JavaScriptオブジェクト（プレーン）{ title: "Hello world" }返すフィールドを決定するには、selectとincludeを使用します。
nullnullレコードが見つかりません

例​

idが42のUserレコードを取得する​
const result = await prisma.user.findUnique({
  where: {
    id: 42,
  },
});
emailがalice@prisma.ioのUserレコードを取得する​
const result = await prisma.user.findUnique({
  where: {
    email: 'alice@prisma.io',
  },
});
firstNameがAliceでlastNameがSmithのUserレコードを取得する（@@unique）​
@@uniqueブロックを持つUserモデルの例を展開
model User {
  firstName String
  lastName  String

  @@unique(fields: [firstName, lastName], name: "fullname")
}
const result = await prisma.user.findUnique({
  where: {
    fullname: {
      // name property of @@unique attribute - default is firstname_lastname
      firstName: 'Alice',
      lastName: 'Smith',
    },
  },
});
firstNameがAliceでlastNameがSmithのUserレコードを取得する（@@id）​
@@idブロックを持つUserモデルの例を展開
model User {
  firstName String
  lastName  String

  @@id([firstName, lastName])
}
const result = await prisma.user.findUnique({
  where: {
    firstName_lastName: {
      firstName: 'Alice',
      lastName: 'Smith',
    },
  },
});

findUniqueOrThrow()​

findUniqueOrThrow()は、findUnique()と同じ方法で単一のレコードを取得します。ただし、クエリが要求されたレコードを見つけられない場合、PrismaClientKnownRequestErrorをスローします。

Prisma v6より前では、NotFoundError: No User found errorエラーがスローされていたことに注意してください。

以下は、その使用例です

await prisma.user.findUniqueOrThrow({
  where: { id: 1 },
});

findUniqueOrThrow()は、findUnique()とは次の点で異なります

  • その戻り値の型はnull許容ではありません。たとえば、post.findUnique()はpostまたはnullを返すことができますが、post.findUniqueOrThrow()は常にpostを返します。

  • これは、$transaction APIのシーケンシャル操作と互換性がありません。クエリがPrismaClientKnownRequestErrorをスローした場合、APIは呼び出し配列内の操作をロールバックしません。回避策として、$transaction APIでインタラクティブトランザクションを使用できます。以下のように

     $transaction(async (prisma) => {
       await prisma.model.create({ data: { ... });
       await prisma.model.findUniqueOrThrow();
     })

findFirst()​

findFirstは、基準に一致するリストの最初のレコードを返します。

備考​

  • レコードが見つからない場合にクエリがエラーをスローするようにする場合は、代わりにfindFirstOrThrowの使用を検討してください。

オプション​

名前型例（User）必須説明
selectXOR<UserSelect, null>いいえ返されるオブジェクトに含めるプロパティを指定します。
includeXOR<UserInclude, null>いいえ返されるオブジェクトに遅延ロードする必要があるリレーションを指定します。
omitXOR<UserOmit, null>いいえ返されるオブジェクトから除外するプロパティを指定します。プレビューは5.13.0以降です。
relationLoadStrategy'join'または'query'いいえデフォルト：join。リレーションクエリのロード戦略を指定します。include（またはリレーションフィールドのselect）との組み合わせでのみ使用可能です。プレビューは5.9.0以降です。
whereUserWhereInputいいえリストを任意のプロパティでフィルタリングできるように、すべてのモデルフィールドを型でラップします。
orderByXOR<Enumerable<UserOrderByInput>, UserOrderByInput>いいえ任意のプロパティで返されるリストを順序付けできます。

戻り値の型​

戻り値の型例説明
JavaScriptオブジェクト（型付き）User返されるオブジェクトに含めるプロパティを指定します。
JavaScriptオブジェクト（プレーン）{ title: "Hello world" }返すフィールドを決定するには、selectとincludeを使用します。
nullnullレコードが見つかりません

備考​

  • findFirstは、バックグラウンドでfindManyを呼び出し、同じクエリオプションを受け入れます。
  • findFirstクエリを使用するときに負のtake値を渡すと、リストの順序が逆になります。

例​

結果をフィルタリングする方法の例については、フィルター条件と演算子を参照してください。

nameがAliceである最初のUserレコードを取得する​
const user = await prisma.user.findFirst({
  where: { name: 'Alice' },
});
titleがA testで始まる最初のPostレコードを取得し、takeでリストを反転する​
import { PrismaClient } from '@prisma/client';

const prisma = new PrismaClient({});

async function main() {
  const a = await prisma.post.create({
    data: {
      title: 'A test 1',
    },
  });

  const b = await prisma.post.create({
    data: {
      title: 'A test 2',
    },
  });

  const c = await prisma.post.findFirst({
    where: {
      title: {
        startsWith: 'A test',
      },
    },
    orderBy: {
      title: 'asc',
    },
    take: -1, // Reverse the list
  });
}

main();

findFirstOrThrow()​

findFirstOrThrow()は、findFirst()と同じ方法で単一のデータレコードを取得します。ただし、クエリがレコードを見つけられない場合、PrismaClientKnownRequestErrorをスローします。

Prisma v6より前では、NotFoundError: No User found errorエラーがスローされていたことに注意してください。

findFirstOrThrow()は、findFirst()とは次の点で異なります

  • その戻り値の型はnull許容ではありません。たとえば、post.findFirst()はpostまたはnullを返すことができますが、post.findFirstOrThrowは常にpostを返します。

  • これは、$transaction APIのシーケンシャル操作と互換性がありません。クエリがPrismaClientKnownRequestErrorを返した場合、APIは呼び出し配列内の操作をロールバックしません。回避策として、$transaction APIでインタラクティブトランザクションを使用できます。以下のように

    prisma.$transaction(async (tx) => {
      await tx.model.create({ data: { ... });
      await tx.model.findFirstOrThrow();
    })

findMany()​

findManyは、レコードのリストを返します。

オプション​

名前型必須説明
selectXOR<PostSelect, null>いいえ返されるオブジェクトに含めるプロパティを指定します。
includeXOR<PostInclude, null>いいえ返されるオブジェクトに遅延ロードする必要があるリレーションを指定します。
omitXOR<PostOmit, null>いいえ返されるオブジェクトから除外するプロパティを指定します。プレビューは5.13.0以降です
relationLoadStrategy'join'または'query'いいえデフォルト：join。リレーションクエリのロード戦略を指定します。include（またはリレーションフィールドのselect）との組み合わせでのみ使用可能です。プレビューは5.9.0以降です。
whereUserWhereInputいいえリストを任意のプロパティでフィルタリングできるように、すべてのモデルフィールドを型でラップします。
orderByXOR<Enumerable<PostOrder
ByInput>, PostOrderByInput>		いいえ任意のプロパティで返されるリストを順序付けできます。
cursorUserWhereUniqueInputいいえリストの位置を指定します（通常、値はidまたは別のunique値を指定します）。
takenumberいいえリストで返すオブジェクトの数を指定します（リストの先頭（正の値）または末尾（負の値）または言及されている場合はcursor位置から見た場合）。
skipnumberいいえリストで返されるオブジェクトのうち、スキップする必要があるオブジェクトの数を指定します。
distinctEnumerable<UserDistinctFieldEnum>いいえ特定のフィールドで重複する行をフィルタリングできます。たとえば、distinctなPostタイトルのみを返します。

戻り値の型​

戻り値の型例説明
JavaScript配列オブジェクト（型付き）User[]
JavaScript配列オブジェクト（プレーン）[{ title: "Hello world" }]返すフィールドを決定するには、selectとincludeを使用します。
空の配列[]一致するレコードが見つかりませんでした。

例​

結果をフィルタリングする方法の例については、フィルター条件と演算子を参照してください。

nameがAliceであるすべてのUserレコードを取得する​
const user = await prisma.user.findMany({
  where: { name: 'Alice' },
});

create()​

createは、新しいデータベースレコードを作成します。

オプション​

名前型必須説明
dataXOR<UserCreateInput,
UserUncheckedCreateInput>		はい新しいレコードを作成するときに提供できるように、モデルフィールドをすべて型でラップします。また、リレーションフィールドも含まれており、（トランザクショナルな）ネストされた挿入を実行できます。データモデルでオプションとしてマークされているフィールドまたはデフォルト値を持つフィールドはオプションです。
selectXOR<UserSelect, null>いいえ返されるオブジェクトに含めるプロパティを指定します。
includeXOR<UserInclude, null>いいえ返されるオブジェクトに遅延ロードする必要があるリレーションを指定します。
omitXOR<UserOmit, null>いいえ返されるオブジェクトから除外するプロパティを指定します。プレビューは5.13.0以降です
relationLoadStrategy'join'または'query'いいえデフォルト：join。リレーションクエリのロード戦略を指定します。include（またはリレーションフィールドのselect）との組み合わせでのみ使用可能です。プレビューは5.9.0以降です。

戻り値の型​

戻り値の型例説明
JavaScriptオブジェクト（型付き）User
JavaScriptオブジェクト（プレーン）{ name: "Alice Wonderland" }返すフィールドを決定するには、selectとincludeを使用します。

備考​

  • ネストされたcreateを実行することもできます。たとえば、Userと2つのPostレコードを同時に追加します。

例​

必須フィールドemailのみを使用して単一の新しいレコードを作成する​
const user = await prisma.user.create({
  data: { email: 'alice@prisma.io' },
});
複数の新しいレコードを作成する​

ほとんどの場合、createMany()またはcreateManyAndReturn()クエリを使用してバッチ挿入を実行できます。ただし、複数のレコードを挿入するのにcreate()が最適なシナリオがあります。

次の例では、2つのINSERTステートメントが生成されます

import { Prisma, PrismaClient } from '@prisma/client';

const prisma = new PrismaClient({ log: ['query'] });

async function main() {
  let users: Prisma.UserCreateInput[] = [
    {
      email: 'ariana@prisma.io',
      name: 'Ari',
      profileViews: 20,
      coinflips: [true, false, false],
      role: 'ADMIN',
    },
    {
      email: 'elsa@prisma.io',
      name: 'Elsa',
      profileViews: 20,
      coinflips: [true, false, false],
      role: 'ADMIN',
    },
  ];

  await Promise.all(
    users.map(async (user) => {
      await prisma.user.create({
        data: user,
      });
    })
  );
}

main()
  .then(async () => {
    await prisma.$disconnect();
  })
  .catch(async (e) => {
    console.error(e);
    await prisma.$disconnect();
    process.exit(1);
  });
表示CLI結果
prisma:query BEGIN
prisma:query INSERT INTO "public"."User" ("name","email","profileViews","role","coinflips") VALUES ($1,$2,$3,$4,$5) RETURNING "public"."User"."id"
prisma:query SELECT "public"."User"."id", "public"."User"."name", "public"."User"."email", "public"."User"."profileViews", "public"."User"."role", "public"."User"."coinflips" FROM "public"."User" WHERE "public"."User"."id" = $1 LIMIT $2 OFFSET $3
prisma:query INSERT INTO "public"."User" ("name","email","profileViews","role","coinflips") VALUES ($1,$2,$3,$4,$5) RETURNING "public"."User"."id"
prisma:query COMMIT
prisma:query SELECT "public"."User"."id", "public"."User"."name", "public"."User"."email", "public"."User"."profileViews", "public"."User"."role", "public"."User"."coinflips" FROM "public"."User" WHERE "public"."User"."id" = $1 LIMIT $2 OFFSET $3
prisma:query COMMIT

update()​

updateは、既存のデータベースレコードを更新します。

オプション​

名前型必須説明
dataXOR<UserUpdateInput
UserUncheckedUpdateInput>		はい既存のレコードを更新するときに提供できるように、モデルのすべてのフィールドをラップします。データモデルでオプションとしてマークされているフィールドまたはデフォルト値を持つフィールドはオプションです。
whereUserWhereUniqueInputはいレコードを選択できるように、モデルのすべてのフィールドをラップします（詳細はこちら）。
バージョン4.5.0より前では、この型はモデルのuniqueフィールドのみをラップしていました。
selectXOR<UserSelect, null>いいえ返されるオブジェクトに含めるプロパティを指定します。
includeXOR<UserInclude, null>いいえ返されるオブジェクトに遅延ロードする必要があるリレーションを指定します。
omitXOR<UserOmit, null>いいえ返されるオブジェクトから除外するプロパティを指定します。プレビューは5.13.0以降です。
relationLoadStrategy'join'または'query'いいえデフォルト：join。リレーションクエリのロード戦略を指定します。include（またはリレーションフィールドのselect）との組み合わせでのみ使用可能です。プレビューは5.9.0以降です。

戻り値の型​

戻り値の型例説明
JavaScriptオブジェクト（型付き）User
JavaScriptオブジェクト（プレーン）{ name: "Alice Wonderland" }返すフィールドを決定するには、selectとincludeを使用します。
RecordNotFound例外レコードが存在しない場合、例外がスローされます。

備考​

  • 更新で算術演算（加算、減算、乗算、除算）を実行するには、アトミック更新を使用して、競合状態を防ぎます。
  • ネストされたupdateを実行することもできます。たとえば、ユーザーとそのユーザーの投稿を同時に更新します。

例​

idが1のUserレコードのemailをalice@prisma.ioに更新する​
const user = await prisma.user.update({
  where: { id: 1 },
  data: { email: 'alice@prisma.io' },
});

upsert()​

情報

このセクションでは、upsert()操作の使用法について説明します。update()内でネストされたupsertクエリを使用する方法については、リンクされたドキュメントを参照してください。

upsertは、以下を実行します

  • 既存のデータベースレコードがwhere条件を満たしている場合、そのレコードを更新します
  • データベースレコードがwhere条件を満たしていない場合、新しいデータベースレコードを作成します

オプション​

名前型必須説明
createXOR<UserCreateInput,
UserUncheckedCreateInput>		はい新しいレコードを作成するときに提供できるように、モデルのすべてのフィールドをラップします。また、リレーションフィールドも含まれており、（トランザクショナルな）ネストされた挿入を実行できます。データモデルでオプションとしてマークされているフィールドまたはデフォルト値を持つフィールドはオプションです。
updateXOR<UserUpdateInput,
UserUncheckedUpdateInput>		はい既存のレコードを更新するときに提供できるように、モデルのすべてのフィールドをラップします。データモデルでオプションとしてマークされているフィールドまたはデフォルト値を持つフィールドはオプションです。
whereUserWhereUniqueInputはいレコードを選択できるように、モデルのすべてのフィールドをラップします（詳細はこちら）。
バージョン4.5.0より前では、この型はモデルのuniqueフィールドのみをラップしていました。
selectXOR<UserSelect, null>いいえ返されるオブジェクトに含めるプロパティを指定します。
includeXOR<UserInclude, null>いいえ返されるオブジェクトに遅延ロードする必要があるリレーションを指定します。
omitXOR<UserOmit, null>いいえ返されるオブジェクトから除外するプロパティを指定します。プレビューは5.13.0以降です
relationLoadStrategy'join'または'query'いいえデフォルト：join。リレーションクエリのロード戦略を指定します。include（またはリレーションフィールドのselect）との組み合わせでのみ使用可能です。プレビューは5.9.0以降です。

戻り値の型​

戻り値の型例説明
JavaScriptオブジェクト（型付き）User
JavaScriptオブジェクト（プレーン）{ name: "Alice Wonderland" }返すフィールドを決定するには、selectとincludeを使用します。

備考​

  • 更新で算術演算（加算、減算、乗算、除算）を実行するには、アトミック更新を使用して、競合状態を防ぎます。
  • 2つ以上のupsert操作が同時に発生し、レコードがまだ存在しない場合、競合状態が発生する可能性があります。その結果、1つ以上のupsert操作がuniqueキー制約エラーをスローする可能性があります。アプリケーションコードでこのエラーをキャッチし、操作を再試行できます。詳細はこちら。
  • バージョン4.6.0以降、Prisma ORMは可能な場合、データベースにupsertクエリを渡します。詳細はこちら。

例​

emailがalice@prisma.ioの新しいUserレコードを更新（存在する場合）または作成する​
const user = await prisma.user.upsert({
  where: { id: 1 },
  update: { email: 'alice@prisma.io' },
  create: { email: 'alice@prisma.io' },
});

upsertのuniqueキー制約エラー​

問題​

複数のupsert操作が同時に発生し、レコードがまだ存在しない場合、操作の1つ以上がuniqueキー制約エラーを返す可能性があります。

原因​

Prisma Clientがupsertを実行すると、最初にそのレコードがデータベースにすでに存在するかどうかを確認します。このチェックを行うために、Prisma Clientはupsert操作のwhere句を使用して読み取り操作を実行します。これには、次の2つの可能な結果があります。

  • レコードが存在しない場合、Prisma Clientはそのレコードを作成します。
  • レコードが存在する場合、Prisma Clientはそれを更新します。

アプリケーションが2つ以上の同時upsert操作を実行しようとすると、2つ以上の操作がレコードを見つけられず、そのレコードを作成しようとする競合状態が発生する可能性があります。この状況では、操作の1つが新しいレコードを正常に作成しますが、他の操作は失敗し、uniqueキー制約エラーを返します。

解決策​

アプリケーションコードでP2002エラーを処理します。発生した場合は、upsert操作を再試行して行を更新します。

データベースupsert​

可能な場合、Prisma Clientはupsertクエリをデータベースに渡します。これはデータベースupsertと呼ばれます。

データベースupsertには、次の利点があります

Prisma Clientは、特定の基準が満たされている場合、データベースupsertを自動的に使用します。これらの基準が満たされていない場合、Prisma Clientはupsertを処理します。

データベースupsertを使用するために、Prisma ClientはSQL構造INSERT ... ON CONFLICT SET .. WHEREをデータベースに送信します。

データベースupsertの前提条件​

スタックが次の基準を満たしている場合、Prisma Clientはデータベースupsertを使用できます

  • Prisma ORMバージョン4.6.0以降を使用している
  • アプリケーションがCockroachDB、PostgreSQL、またはSQLiteデータソースを使用している
データベースupsertクエリの基準​

Prisma Clientは、クエリが次の基準を満たす場合、upsertクエリにデータベースupsertを使用します

  • upsertのcreateおよびupdateオプションにネストされたクエリがない
  • クエリには、ネストされた読み取りを使用する選択が含まれていない
  • クエリは1つのモデルのみを変更する
  • upsertのwhereオプションにはuniqueフィールドが1つしかない
  • whereオプションのuniqueフィールドとcreateオプションのuniqueフィールドの値が同じである

クエリがこれらの基準を満たしていない場合、Prisma Clientはupsert自体を処理します。

データベースupsertの例​

次の例では、このスキーマを使用しています

model User {
  id           Int    @id
  profileViews Int
  userName     String @unique
  email        String

  @@unique([id, profileViews])
}

次のupsertクエリはすべての基準を満たしているため、Prisma Clientはデータベースupsertを使用します。

prisma.user.upsert({
  where: {
    userName: 'Alice',
  },
  create: {
    id: 1,
    profileViews: 1,
    userName: 'Alice',
    email: 'alice@prisma.io',
  },
  update: {
    email: 'updated@example.com',
  },
});

この状況では、Prismaは次のSQLクエリを使用します

INSERT INTO "public"."User" ("id","profileViews","userName","email") VALUES ($1,$2,$3,$4)
ON CONFLICT ("userName") DO UPDATE
SET "email" = $5 WHERE ("public"."User"."userName" = $6 AND 1=1) RETURNING "public"."User"."id", "public"."User"."profileViews", "public"."User"."userName", "public"."User"."email"

以下のクエリには、where句に複数の一意な値があるため、Prisma Client はデータベースの upsert を使用しません。

prisma.User.upsert({
  where: {
    userName: 'Alice',
    profileViews: 1,
    id: 1,
  },
  create: {
    id: 1,
    profileViews: 1,
    userName: 'Alice',
    email: 'alice@prisma.io',
  },
  update: {
    email: 'updated@example.com',
  },
});

以下のクエリでは、whereオプションとcreateオプションのuserNameの値が異なるため、Prisma Client はデータベースの upsert を使用しません。

prisma.User.upsert({
  where: {
    userName: 'Alice',
  },
  create: {
    id: 1,
    profileViews: 1,
    userName: 'AliceS',
    email: 'alice@prisma.io',
  },
  update: {
    email: 'updated@example.com',
  },
});

以下のクエリでは、postsのtitleフィールドの選択がネストされた読み取りであるため、Prisma Client はデータベースの upsert を使用しません。

prisma.user.upsert({
  select: {
    email: true,
    id: true,
    posts: {
      select: {
        title: true,
      },
    },
  },
  where: {
    userName: 'Alice',
  },

  create: {
    id: 1,
    profileViews: 1,
    userName: 'Alice',
    email: 'alice@prisma.io',
  },
  update: {
    email: 'updated@example.com',
  },
});

delete()​

delete は既存のデータベースレコードを削除します。レコードを削除するには、

  • ID別
  • unique属性別

特定の条件に一致するレコードを削除するには、フィルターを指定してdeleteManyを使用します。

オプション​

名前型必須説明
whereUserWhereUniqueInputはいレコードを選択できるように、モデルのすべてのフィールドをラップします（詳細はこちら）。
バージョン4.5.0より前では、この型はモデルのuniqueフィールドのみをラップしていました。
selectXOR<UserSelect, null>いいえ返されるオブジェクトに含めるプロパティを指定します。
includeXOR<UserInclude, null>いいえ返されるオブジェクトに遅延ロードする必要があるリレーションを指定します。
omitXOR<UserOmit, null>いいえ返されるオブジェクトから除外するプロパティを指定します。プレビューは5.13.0以降です
relationLoadStrategy'join'または'query'いいえデフォルト：join。リレーションクエリのロード戦略を指定します。include（またはリレーションフィールドのselect）との組み合わせでのみ使用可能です。プレビューは5.9.0以降です。

戻り値の型​

戻り値の型例説明
JavaScriptオブジェクト（型付き）User削除されたUserレコード。
JavaScriptオブジェクト（プレーン）{ name: "Alice Wonderland" }削除されたUserレコードからのデータ。返すフィールドを決定するには、selectおよびincludeを使用します。
RecordNotFound例外レコードが存在しない場合は例外をスローします。

備考​

  • 特定の条件（たとえば、prisma.ioのメールアドレスを持つすべてのUserレコード）に基づいて複数のレコードを削除するには、deleteManyを使用します。

例​

idが1のUserレコードを削除する​
const user = await prisma.user.delete({
  where: { id: 1 },
});
emailがelse@prisma.ioと等しいUserレコードを削除する​

以下のクエリは、特定のユーザーレコードを削除し、削除されたユーザーのnameとemailを返すためにselectを使用します。

const deleteUser = await prisma.user.delete({
  where: {
    email: 'elsa@prisma.io',
  },
  select: {
    email: true,
    name: true,
  },
});
表示CLI結果
{ "email": "elsa@prisma.io", "name": "Elsa" }

createMany()​

createManyは、トランザクション内で複数のレコードを作成します。

オプション​

名前型必須説明
dataEnumerable<UserCreateManyInput>はい新しいレコードを作成するときに指定できるように、すべてのモデルフィールドを型でラップします。データモデルでオプションとしてマークされているフィールドまたはデフォルト値を持つフィールドはオプションです。
skipDuplicates?booleanいいえ一意のフィールドまたは既に存在するIDフィールドを持つレコードを挿入しません。ON CONFLICT DO NOTHINGをサポートするデータベースでのみサポートされています。これには、MongoDBとSQLServerは含まれません。

戻り値の型​

戻り値の型例説明
BatchPayload{ count: 3 }作成されたレコード数のカウント。

備考​

  • Prisma ORM バージョン 5.12.0 以降、createMany() は SQLite でサポートされるようになりました。
  • skipDuplicatesオプションは、MongoDB、SQLServer、または SQLite ではサポートされていません。
  • トップレベルのcreateMany()クエリ内で、ネストされたcreate、createMany、connect、connectOrCreateクエリを使用してリレーションを作成または接続することはできません。 回避策については、こちらをご覧ください。
  • ネストされたcreateManyクエリをupdate()またはcreate()クエリ内で使用できます。たとえば、Userと2つのPostレコードをネストされたcreateManyで同時に追加します。

例​

複数の新しいユーザーを作成する​
const users = await prisma.user.createMany({
  data: [
    { name: 'Sonali', email: 'sonali@prisma.io' },
    { name: 'Alex', email: 'alex@prisma.io' },
  ],
});

createManyAndReturn()​

createManyAndReturnは、複数のレコードを作成し、結果のオブジェクトを返します。

情報

この機能は、Prisma ORM バージョン 5.14.0 以降の PostgreSQL、CockroachDB、および SQLite で利用可能です。

オプション​

名前型必須説明
dataEnumerable<UserCreateManyInput>はい新しいレコードを作成するときに指定できるように、すべてのモデルフィールドを型でラップします。データモデルでオプションとしてマークされているフィールドまたはデフォルト値を持つフィールドはオプションです。
selectXOR<UserSelect, null>いいえ返すオブジェクトに含めるプロパティを指定します。
omitXOR<UserOmit, null>いいえ返すオブジェクトから除外するプロパティを指定します。 5.13.0 以降プレビューで提供されています。selectと相互に排他的です。
includeXOR<UserInclude, null>いいえ返すオブジェクトに事前にロードする必要があるリレーションを指定します。
skipDuplicates?booleanいいえ一意のフィールドまたは既に存在するIDフィールドを持つレコードを挿入しません。ON CONFLICT DO NOTHINGをサポートするデータベースでのみサポートされています。これには、MongoDBとSQLServerは含まれません。

備考​

  • skipDuplicatesオプションは、SQLite ではサポートされていません。
  • トップレベルのcreateManyAndReturn()クエリ内で、ネストされたcreate、createMany、connect、connectOrCreateクエリを使用してリレーションを作成または接続することはできません。 回避策については、こちらをご覧ください。
  • includeを介してリレーションが含まれる場合、リレーションごとに個別のクエリが生成されます。
  • relationLoadStrategy: joinはサポートされていません。

戻り値の型​

戻り値の型例説明
JavaScript配列オブジェクト（型付き）User[]
JavaScript配列オブジェクト（プレーン）[{ name: "Sonali" }]返すフィールドを決定するには、select、omit、およびincludeを使用します。

例​

複数の新しいユーザーを作成して返す​
const users = await prisma.user.createManyAndReturn({
  data: [
    { name: 'Sonali', email: 'sonali@prisma.io' },
    { name: 'Alex', email: 'alex@prisma.io' },
  ],
})
表示CLI結果
[
  { "id": 0, "name": "Sonali", "email": "sonali@prisma.io", "profileViews": 0 },
  { "id": 1, "name": "Alex", "email": "alex@prisma.io", "profileViews": 0  }
]

updateMany()​

updateManyは、既存のデータベースレコードのバッチを一括で更新し、更新されたレコード数を返します。

オプション​

名前型必須説明
dataXOR<UserUpdateManyMutationInput,
UserUncheckedUpdateManyInput>		はい既存のレコードを更新するときに指定できるように、モデルのすべてのフィールドをラップします。データモデルでオプションとしてマークされているフィールドまたはデフォルト値を持つフィールドは、dataではオプションです。
whereUserWhereInputいいえモデルのすべてのフィールドをラップして、リストを任意のプロパティでフィルタリングできるようにします。リストをフィルタリングしない場合、すべてのレコードが更新されます。
limitnumberいいえ更新するレコード数を制限します。

戻り値の型​

戻り値の型例説明
BatchPayload{ count: 4 }更新されたレコードの数。
export type BatchPayload = {
  count: number;
};

例​

nameがAliceであるすべてのUserレコードをALICEに更新する​
const updatedUserCount = await prisma.user.updateMany({
  where: { name: 'Alice' },
  data: { name: 'ALICE' },
});
emailにprisma.ioが含まれ、少なくとも1つの関連するPostが10を超えるいいねを持っているすべてのUserレコードを更新する​
const updatedUserCount = await prisma.user.updateMany({
  where: {
    email: {
      contains: 'prisma.io',
    },
    posts: {
      some: {
        likes: {
          gt: 10,
        },
      },
    },
  },
  data: {
    role: 'USER',
  },
});
emailにprisma.ioが含まれるUserレコードを更新しますが、更新されるレコード数を5つに制限します。​
const updatedUserCount = await prisma.user.updateMany({
  where: {
    email: {
      contains: 'prisma.io',
    },
  },
  data: {
    role: 'USER',
  },
  limit: 5,
});

updateManyAndReturn()​

情報

この機能は、Prisma ORM バージョン 6.2.0 以降の PostgreSQL、CockroachDB、および SQLite で利用可能です。

updateManyAndReturnは、複数のレコードを更新し、結果のオブジェクトを返します。

オプション​

名前型必須説明
dataXOR<UserUpdateManyMutationInput,
UserUncheckedUpdateManyInput>		はい既存のレコードを更新するときに指定できるように、モデルのすべてのフィールドをラップします。データモデルでオプションとしてマークされているフィールドまたはデフォルト値を持つフィールドは、dataではオプションです。
whereUserWhereInputいいえモデルのすべてのフィールドをラップして、リストを任意のプロパティでフィルタリングできるようにします。リストをフィルタリングしない場合、すべてのレコードが更新されます。

戻り値の型​

戻り値の型例説明
JavaScript配列オブジェクト（型付き）User[]
JavaScript配列オブジェクト（プレーン）[{ name: "Sonali" }]返すフィールドを決定するには、select、omit、およびincludeを使用します。

例​

複数のユーザーを更新して返す​
const users = await prisma.user.updateManyAndReturn({
  where: {
    email: {
      contains: 'prisma.io',
    }
  },
  data: [
    { role: 'ADMIN' }
  ],
})
表示CLI結果
[
  { "id": 0, "name": "Sonali", "email": "sonali@prisma.io", "role": "ADMIN", "profileViews": 0 },
  { "id": 1, "name": "Alex", "email": "alex@prisma.io", "role": "ADMIN", "profileViews": 0  }
]

deleteMany()​

deleteManyは、トランザクション内で複数のレコードを削除します。

オプション​

名前型必須説明
whereUserWhereInputいいえモデルのすべてのフィールドをラップして、リストを任意のフィールドでフィルタリングできるようにします。
limitIntいいえ削除されるレコード数を制限します。

戻り値の型​

戻り値の型例説明
BatchPayload{ count: 4 }削除されたレコードの数。
export type BatchPayload = {
  count: number;
};

例​

すべてのUserレコードを削除する​
const deletedUserCount = await prisma.user.deleteMany({});
nameがAliceであるすべてのUserレコードを削除する​
const deletedUserCount = await prisma.user.deleteMany({
  where: { name: 'Alice' },
});
emailにprisma.ioが含まれるすべてのUserレコードを削除しますが、削除されるレコード数を5つに制限します。​
const deletedUserCount = await prisma.user.deleteMany({
  where: {
    email: {
      contains: 'prisma.io',
    },
  },
  limit: 5,
});

削除するレコードをフィルタリングする方法の例については、フィルター条件と演算子を参照してください。

count()​

オプション​

名前型必須説明
whereUserWhereInputいいえリストを任意のプロパティでフィルタリングできるように、すべてのモデルフィールドを型でラップします。
orderByXOR<Enumerable<PostOrder
ByInput>, PostOrderByInput>		いいえ任意のプロパティで返されるリストを順序付けできます。
cursorUserWhereUniqueInputいいえリストの位置を指定します（通常、値はidまたは別のunique値を指定します）。
takenumberいいえリストで返すオブジェクトの数を指定します（リストの先頭（正の値）または末尾（負の値）または言及されている場合はcursor位置から見た場合）。
skipnumberいいえリストで返されるオブジェクトのうち、スキップする必要があるオブジェクトの数を指定します。

戻り値の型​

戻り値の型例説明
number29レコードの数。
UserCountAggregateOutputType{ _all: 27, name: 10 }selectが使用されている場合に返されます。

例​

すべてのUserレコードをカウントする​
const result = await prisma.user.count();
少なくとも1つの公開されたPostを持つすべてのUserレコードをカウントする​
const result = await prisma.user.count({
  where: {
    post: {
      some: {
        published: true,
      },
    },
  },
});
selectを使用して3つの個別のカウントを実行する​

以下のクエリは以下を返します

  • すべてのレコードのカウント（_all）
  • 非nullのnameフィールドを持つすべてのレコードのカウント
  • 非nullのcityフィールドを持つすべてのレコードのカウント
const c = await prisma.user.count({
  select: {
    _all: true,
    city: true,
    name: true,
  },
});

aggregate()​

こちらも参照してください：集計、グループ化、および要約

オプション​

名前型必須説明
whereUserWhereInputいいえリストを任意のプロパティでフィルタリングできるように、すべてのモデルフィールドを型でラップします。
orderByXOR<Enumerable<UserOrderByInput>,
UserOrderByInput>		いいえ任意のプロパティで返されるリストを順序付けできます。
cursorUserWhereUniqueInputいいえリストの位置を指定します（通常、値はidまたは別のunique値を指定します）。
takenumberいいえリストで返すオブジェクトの数を指定します（リストの先頭（正の値）または末尾（負の値）または言及されている場合はcursor位置から見た場合）。
skipnumberいいえリストで返されるオブジェクトのうち、スキップする必要があるオブジェクトの数を指定します。
_counttrueいいえ一致するレコードまたは非nullフィールドの数を返します。
_avgUserAvgAggregateInputTypeいいえ指定されたフィールドのすべての値の平均を返します。
_sumUserSumAggregateInputTypeいいえ指定されたフィールドのすべての値の合計を返します。
_minUserMinAggregateInputTypeいいえ指定されたフィールドで使用可能な最小値を返します。
_maxUserMaxAggregateInputTypeいいえ指定されたフィールドで使用可能な最大値を返します。

例​

すべてのUserレコードのprofileViewsの_min、_max、および_countを返す​
const minMaxAge = await prisma.user.aggregate({
  _count: {
    _all: true,
  },
  _max: {
    profileViews: true,
  },
  _min: {
    profileViews: true,
  },
});
表示CLI結果
すべてのUserレコードのprofileViewsの_sumを返す​
const setValue = await prisma.user.aggregate({
  _sum: {
    profileViews: true,
  },
});
表示CLI結果

groupBy()​

こちらも参照してください：集計、グループ化、および要約

オプション​

名前型必須説明
whereUserWhereInputいいえリストを任意のプロパティでフィルタリングできるように、すべてのモデルフィールドを型でラップします。
orderByXOR<Enumerable<UserOrderByInput>,
UserOrderByInput>		いいえbyにも存在する任意のプロパティで、返されるリストを並べ替えることができます。
byArray<UserScalarFieldEnum> | stringいいえレコードをグループ化するフィールドまたはフィールドの組み合わせを指定します。
havingUserScalarWhereWithAggregatesInputいいえ集計値でグループをフィルタリングできます。たとえば、平均年齢が50歳未満のグループのみを返します。
takenumberいいえリストで返すオブジェクトの数を指定します（リストの先頭（正の値）または末尾（負の値）または言及されている場合はcursor位置から見た場合）。
skipnumberいいえリストで返されるオブジェクトのうち、スキップする必要があるオブジェクトの数を指定します。
_counttrue | UserCountAggregateInputTypeいいえ一致するレコードまたは非nullフィールドの数を返します。
_avgUserAvgAggregateInputTypeいいえ指定されたフィールドのすべての値の平均を返します。
_sumUserSumAggregateInputTypeいいえ指定されたフィールドのすべての値の合計を返します。
_minUserMinAggregateInputTypeいいえ指定されたフィールドで使用可能な最小値を返します。
_maxUserMaxAggregateInputTypeいいえ指定されたフィールドで使用可能な最大値を返します。

例​

profileViewsの平均が200より大きいcountry/cityでグループ化し、各グループのprofileViewsの_sumを返す​

クエリは、各グループの_allレコードの数と、各グループの非nullのcityフィールド値を持つすべてのレコードも返します。

const groupUsers = await prisma.user.groupBy({
  by: ['country', 'city'],
  _count: {
    _all: true,
    city: true,
  },
  _sum: {
    profileViews: true,
  },
  orderBy: {
    country: 'desc',
  },
  having: {
    profileViews: {
      _avg: {
        gt: 200,
      },
    },
  },
});
表示CLI結果
[
  {
    country: 'Denmark',
    city: 'Copenhagen',
    _sum: { profileViews: 490 },
    _count: {
      _all: 70,
      city: 8,
    },
  },
  {
    country: 'Sweden',
    city: 'Stockholm',
    _sum: { profileViews: 500 },
    _count: {
      _all: 50,
      city: 3,
    },
  },
];

findRaw()​

参照：Raw SQL の使用 (findRaw())。

aggregateRaw()​

参照：Raw SQL の使用 (aggregateRaw())。

モデルクエリオプション​

select​

selectは、Prisma Client が返すオブジェクトに含めるフィールドを定義します。参照：フィールドの選択とリレーションの include。

備考​

例​

単一のUserレコードのnameフィールドとprofileViewsフィールドを選択する​
const result = await prisma.user.findUnique({
  where: { id: 1 },
  select: {
    name: true,
    profileViews: true,
  },
});
表示CLI結果
複数のUserレコードのemailフィールドとroleフィールドを選択する​
const result = await prisma.user.findMany({
  select: {
    email: true,
    role: true,
  },
});
表示CLI結果
リレーションの_countを選択する​
const usersWithCount = await prisma.user.findMany({
  select: {
    _count: {
      select: { posts: true },
    },
  },
});
表示CLI結果
関連するPostレコードの「id」フィールドと「title」フィールドを選択する​
const result = await prisma.user.findMany({
  select: {
    id: true,
    name: true,
    posts: {
      select: {
        id: true,
        title: true,
      },
    },
  },
});
表示CLI結果
select内のinclude​
const result = await prisma.user.findMany({
  select: {
    id: true,
    name: true,
    posts: {
      include: {
        author: true,
      },
    },
  },
});
表示CLI結果

selectの生成された型​

以下の例は、validatorをselectで使用する方法を示しています

const selectNameEmailNotPosts = Prisma.validator<Prisma.UserSelect>()({
  name: true,
  email: true,
  posts: false,
});

include​

includeは、Prisma Client が返す結果に含めるリレーションを定義します。参照：フィールドの選択とリレーションの include。

備考​

例​

Userレコードをロードするときにpostsとprofileリレーションを含める​
const users = await prisma.user.findMany({
  include: {
    posts: true, // Returns all fields for all posts
    profile: true, // Returns all Profile fields
  },
});
2つのPostレコードを持つ新しいUserレコードを作成するときに、返されたオブジェクトにpostsリレーションを含める​
const user = await prisma.user.create({
  data: {
    email: 'alice@prisma.io',
    posts: {
      create: [{ title: 'This is my first post' }, { title: 'Here comes a second post' }],
    },
  },
  include: { posts: true }, // Returns all fields for all posts
});

includeの生成された型​

以下の例は、validatorをincludeで使用する方法を示しています

const includePosts = Prisma.validator<Prisma.UserInclude>()({
  posts: true,
});
リレーションの_countを含める​
const usersWithCount = await prisma.user.findMany({
  include: {
    _count: {
      select: { posts: true },
    },
  },
});
表示CLI結果

omit​

omitは、Prisma Client が返すオブジェクトから除外するフィールドを定義します。

備考​

  • omitとselectは反対の目的を果たすため、組み合わせることはできません
  • omitは、Prisma ORM 6.2.0 で一般提供になりました。 Prisma ORM バージョン 5.13.0 から 6.1.0 では、omitApi プレビュー機能を介して利用できました。

例​

すべてのUserレコードからpasswordフィールドを省略する​
const result = await prisma.user.findMany({
  omit: {
    password: true,
  },
});
表示CLI結果
すべてのUserのpostsリレーションからtitleフィールドを省略する​
const results = await prisma.user.findMany({
  omit: {
    password: true,
  },
  include: {
    posts: {
      omit: {
        title: true,
      },
    },
  },
});
表示CLI結果

omitの生成された型​

以下の例は、validatorをomitで使用する方法を示しています

const omitPassword = Prisma.validator<Prisma.UserOmit>()({
  password: true,
});

relationLoadStrategy（プレビュー）​

relationLoadStrategyは、リレーションをデータベースからロードする方法を指定します。次の2つの可能な値があります

  • join（デフォルト）：データベースレベルのLATERAL JOIN（PostgreSQL）または相関サブクエリ（MySQL）を使用し、データベースへの単一のクエリですべてのデータをフェッチします。
  • query：複数のクエリをデータベースに送信し（テーブルごとに1つ）、アプリケーションレベルで結合します。

注：relationLoadStrategyがプレビューから一般提供に移行すると、joinはすべてのリレーションクエリのデフォルトとして普遍的になります。

結合戦略の詳細については、こちらをご覧ください。

relationLoadStrategyオプションは現在プレビュー段階であるため、Prisma スキーマファイルのrelationJoinsプレビュー機能フラグを有効にする必要があります

generator client {
  provider        = "prisma-client-js"
  previewFeatures = ["relationJoins"]
}

このフラグを追加したら、Prisma Client を再生成するためにprisma generateを再度実行する必要があります。 relationJoins機能は、現在 PostgreSQL、CockroachDB、および MySQL で利用可能です。

備考​

  • ほとんどの場合、デフォルトのjoin戦略の方が効果的です。データベースサーバーのリソースを節約したい場合、またはアプリケーションレベルの結合の方がパフォーマンスが高いことをプロファイリングで示す場合は、queryを使用してください。
  • relationLoadStrategyは、クエリのトップレベルでのみ指定できます。トップレベルの選択は、すべてのネストされたサブクエリに影響します。

例​

includeを使用する場合に、データベースレベルの JOIN を介してpostsリレーションをロードする​
const users = await prisma.user.findMany({
  relationLoadStrategy: 'join',
  include: {
    posts: true,
  },
});
selectを使用する場合に、データベースレベルの JOIN を介してpostsリレーションをロードする​
const users = await prisma.user.findMany({
  relationLoadStrategy: 'join',
  select: {
    posts: true,
  },
});

where​

whereは、1つ以上のフィルターを定義し、レコードプロパティ（ユーザーのメールアドレスなど）または関連するレコードプロパティ（ユーザーの最新の投稿タイトルのトップ10など）でフィルタリングするために使用できます。

例​

const results = await prisma.user.findMany({
  where: {
    email: {
      endsWith: 'prisma.io',
    },
  },
});

whereの生成された型​

以下の例は、validatorをwhereで使用する方法を示しています

  • UserWhereInput

    // UserWhereInput
    const whereNameIs = Prisma.validator<Prisma.UserWhereInput>()({
      name: 'Rich',
    });

    // It can be combined with conditional operators too
    const whereNameIs = Prisma.validator<Prisma.UserWhereInput>()({
      name: 'Rich',
      AND: [
        {
          email: {
            contains: 'rich@boop.com',
          },
        },
      ],
    });

  • UserWhereUniqueInput この型は、モデルの一意のフィールドを公開することで機能します。 @idが割り当てられたフィールドは一意と見なされ、@uniqueが割り当てられたフィールドも同様です。

    バージョン 4.5.0 以降、この型はモデルのすべてのフィールドを公開します。これは、一意のフィールドに基づいて単一のレコードをフィルタリングするときに、追加の非一意フィールドと一意フィールドを同時にチェックできることを意味します。詳細はこちら。

    // UserWhereUniqueInput
    const whereEmailIsUnique = Prisma.validator<Prisma.UserWhereUniqueInput>()({
      email: 'rich@boop.com',
    })

  • PostScalarWhereInput

    const whereScalarTitleIs = Prisma.validator<Prisma.PostScalarWhereInput>()({
      title: 'boop',
    });

  • PostUpdateWithWhereUniqueWithoutAuthorInput - この型は、一意のwhereフィールド（@idまたは別の割り当てられた@unique）を受け入れ、Authorを除くPostモデルの任意のフィールドを更新します。 Authorは、Postモデルのスカラーフィールドです。

    const updatePostByIdWithoutAuthor =
      Prisma.validator<Prisma.PostUpdateWithWhereUniqueWithoutAuthorInput>()({
        where: {
          id: 1,
        },
        data: {
          content: 'This is some updated content',
          published: true,
          title: 'This is a new title',
        },
      });

  • PostUpsertWithWhereUniqueWithoutAuthorInput - この型は、IDが一致するPostレコードのtitleフィールドを更新し、存在しない場合は代わりに作成します。

    const updatePostTitleOrCreateIfNotExist =
      Prisma.validator<Prisma.PostUpsertWithWhereUniqueWithoutAuthorInput>()({
        where: {
          id: 1,
        },
        update: {
          title: 'This is a new title',
        },
        create: {
          id: 1,
          title: 'If the title doesnt exist, then create one with this text',
        },
      });

  • PostUpdateManyWithWhereWithoutAuthorInput - この型は、publishedがfalseに設定されているすべてのPostレコードを更新します。

    const publishAllPosts = Prisma.validator<Prisma.PostUpdateManyWithWhereWithoutAuthorInput>()({
      where: {
        published: {
          equals: false,
        },
      },
      data: {
        published: true,
      },
    });

orderBy​

レコードのリストをソートします。こちらも参照してください：ソート

備考​

sort引数の入力​

名前説明
asc昇順ソート（A → Z）
desc降順ソート（Z → A）

nulls引数の入力​

注

  • この引数はオプションです。
  • オプションのスカラーフィールドでのみ使用できます。必須フィールドまたはリレーションフィールドで null でソートしようとすると、Prisma Client はP2009 エラーをスローします。
  • バージョン 4.1.0 以降で、プレビュー機能として利用可能です。機能の有効化方法の詳細については、null を最初または最後にソートを参照してください。
名前説明
firstnull値を最初にソートします。
lastnull値を最後にソートします。

例​

Userをemailフィールドでソートする​

以下の例は、emailで昇順にソートされたすべてのUserレコードを返します

const users = await prisma.user.findMany({
  orderBy: {
    email: 'asc',
  },
});

次の例では、User レコードをすべてemail の降順でソートして返します。

const users = await prisma.user.findMany({
  orderBy: {
    email: 'desc',
  },
});

関連する User レコードの name で Post をソート​

次のクエリは、投稿をユーザー名で順序付けます。

const posts = await prisma.post.findMany({
  orderBy: {
    author: {
      name: 'asc',
    },
  },
});

関連する User レコードの name で Post をソートし、null レコードを最初にします。​

次のクエリは、投稿をユーザー名で順序付け、null レコードを最初にします。

const posts = await prisma.post.findMany({
  orderBy: {
    author: {
      name: { sort: 'asc', nulls: 'first' },
    },
  },
});

タイトルの関連性で Post をソート​

情報

PostgreSQL の場合、この機能はまだプレビュー段階です。使用するには、fullTextSearchPostgres 機能フラグを有効にしてください。

次のクエリは、検索語句 'database' のタイトルへの関連性で投稿を順序付けます。

const posts = await prisma.post.findMany({
  orderBy: {
    _relevance: {
      fields: ['title'],
      search: 'database',
      sort: 'asc'
    },
})

posts カウントで User をソート​

次のクエリは、ユーザーを投稿数で順序付けます。

const getActiveusers = await prisma.user.findMany({
  orderBy: {
    posts: {
      count: 'desc',
    },
  },
});
複数のフィールド (email および role) で User をソート​

次の例では、ユーザーを 2 つのフィールド (最初に email、次に role) でソートします。

const users = await prisma.user.findMany({
  select: {
    email: true,
    role: true,
  },
  orderBy: [
    {
      email: 'desc',
    },
    {
      role: 'desc',
    },
  ],
});
表示CLI結果

ソートパラメータの順序が重要です。次のクエリは、最初に role、次に email でソートします。結果の違いに注意してください。

const users = await prisma.user.findMany({
  select: {
    email: true,
    role: true,
  },
  orderBy: [
    {
      role: 'desc',
    },
    {
      email: 'desc',
    },
  ],
});
表示CLI結果
email で User をソートし、name と email を選択​

次の例では、すべての User レコードのすべての name フィールドと email フィールドを、email でソートして返します。

const users3 = await prisma.user.findMany({
  orderBy: {
    email: 'asc',
  },
  select: {
    name: true,
    email: true,
  },
});
表示CLI結果
email で User レコードをソートし、ネストされた Post レコードを title でソート​

次の例：

  • email でソートされたすべての User レコードを返します。
  • 各 User レコードについて、title でソートされたすべてのネストされた Post レコードの title フィールドを返します。
const usersWithPosts = await prisma.user.findMany({
  orderBy: {
    email: 'asc',
  },
  include: {
    posts: {
      select: {
        title: true,
      },
      orderBy: {
        title: 'asc',
      },
    },
  },
});
表示CLI結果
1 人のユーザーのネストされた Post レコードのリストをソート​

次の例では、ID で単一の User レコードを取得し、title でソートされたネストされた Post レコードのリストも取得します。

const userWithPosts = await prisma.user.findUnique({
  where: {
    id: 1,
  },
  include: {
    posts: {
      orderBy: {
        title: 'desc',
      },
      select: {
        title: true,
        published: true,
      },
    },
  },
});
表示CLI結果
enum でソート​

次は、すべての User レコードを role (enum) でソートします。

const sort = await prisma.user.findMany({
  orderBy: {
    role: 'desc',
  },
  select: {
    email: true,
    role: true,
  },
});
表示CLI結果

orderBy の生成された型​

次の例は、validator を orderBy で使用する方法を示しています。

  • UserOrderByInput 
    const orderEmailsByDescending = Prisma.validator<Prisma.UserOrderByInput>()({
      email: 'desc',
    });

distinct​

findMany または findFirst からのレコードのリストを重複排除します。以下も参照してください：集計、グループ化、および要約

例​

単一フィールドで distinct を選択​

次の例では、すべての異なる city フィールドを返し、city フィールドと country フィールドのみを選択します。

const distinctCities = await prisma.user.findMany({
  select: {
    city: true,
    country: true,
  },
  distinct: ['city'],
});
表示CLI結果
[
  { city: 'Paris', country: 'France' },
  { city: 'Lyon', country: 'France' },
];
複数フィールドで distinct を選択​

次の例では、すべての異なる city および country フィールドの組み合わせを返し、city フィールドと country フィールドのみを選択します。

const distinctCitiesAndCountries = await prisma.user.findMany({
  select: {
    city: true,
    country: true,
  },
  distinct: ['city', 'country'],
});
表示CLI結果
[
  { city: 'Paris', country: 'France' },
  { city: 'Paris', country: 'Denmark' },
  { city: 'Lyon', country: 'France' },
];

「パリ、デンマーク」が「パリ、フランス」に加えて存在することに注意してください。

フィルターと組み合わせて distinct を選択​

次の例では、ユーザーのメールに "prisma.io" が含まれるすべての異なる city および country フィールドの組み合わせを返し、city フィールドと country フィールドのみを選択します。

const distinctCitiesAndCountries = await prisma.user.findMany({
  where: {
    email: {
      contains: 'prisma.io',
    },
  },
  select: {
    city: true,
    country: true,
  },
  distinct: ['city', 'country'],
});
表示CLI結果

nativeDistinct​

Prisma スキーマで nativeDistinct を有効にすると、distinct 操作がデータベースレイヤーにプッシュされます（サポートされている場合）。これにより、パフォーマンスが大幅に向上する可能性があります。ただし、次の点に注意してください。

  • 一部のデータベースは、特定のフィールドの組み合わせに対する DISTINCT を完全にサポートしていない場合があります。
  • プロバイダー間で動作が異なる場合があります。

nativeDistinct を有効にするには

generator client {
  provider        = "prisma-client-js"
  previewFeatures = ["nativeDistinct"]
}

詳細については、プレビュー機能を参照してください。

ネストされたクエリ​

create​

ネストされた create クエリは、新しい関連レコードまたはレコードのセットを親レコードに追加します。参照：リレーションの操作

備考​

  • create は、新しい親レコードを create() (prisma.user.create(...)) するか、既存の親レコードを update() (prisma.user.update(...)) する場合に、ネストされたクエリとして使用できます。
  • ネストされた create または ネストされた createMany を使用して、複数の関連レコードを作成できます。skipDuplicates クエリオプションが必要な場合は、createMany を使用する必要があります。

例​

新しい Profile レコードを持つ新しい User レコードを作成​
const user = await prisma.user.create({
  data: {
    email: 'alice@prisma.io',
    profile: {
      create: { bio: 'Hello World' },
    },
  },
});
新しい User レコードを持つ新しい Profile レコードを作成​
const user = await prisma.profile.create({
  data: {
    bio: 'Hello World',
    user: {
      create: { email: 'alice@prisma.io' },
    },
  },
})
新しい Post レコードを持つ新しい User レコードを作成​
const user = await prisma.user.create({
  data: {
    email: 'alice@prisma.io',
    posts: {
      create: { title: 'Hello World' },
    },
  },
});
2 つの新しい Post レコードを持つ新しい User レコードを作成​

これは一対多のリレーションであるため、create に配列を渡すことで、複数の Post レコードを一度に作成することもできます。

const user = await prisma.user.create({
  data: {
    email: 'alice@prisma.io',
    posts: {
      create: [
        {
          title: 'This is my first post',
        },
        {
          title: 'Here comes a second post',
        },
      ],
    },
  },
});

注：ネストされた createMany を使用して、同じ結果を実現することもできます。

新しい Profile レコードを作成して、既存の User レコードを更新​
const user = await prisma.user.update({
  where: { email: 'alice@prisma.io' },
  data: {
    profile: {
      create: { bio: 'Hello World' },
    },
  },
});
新しい Post レコードを作成して、既存の User レコードを更新​
const user = await prisma.user.update({
  where: { email: 'alice@prisma.io' },
  data: {
    posts: {
      create: { title: 'Hello World' },
    },
  },
})

createMany​

ネストされた createMany クエリは、新しいレコードのセットを親レコードに追加します。参照：リレーションの操作

備考​

  • createMany は、新しい親レコードを create() (prisma.user.create(...)) するか、既存の親レコードを update() (prisma.user.update(...)) する場合に、ネストされたクエリとして使用できます。
    • 一対多のリレーションのコンテキストで使用できます。たとえば、ユーザーを prisma.user.create(...) し、ネストされた createMany を使用して複数の投稿を作成できます（投稿には 1 人のユーザーがいます）。
    • 多対多のリレーションのコンテキストでは使用できません。たとえば、投稿を prisma.post.create(...) し、ネストされた createMany を使用してカテゴリを作成することはできません（多くの投稿には多くのカテゴリがあります）。
  • 追加の create または createMany をネストすることはできません。
  • 外部キーを直接設定できます。たとえば、投稿に categoryId を設定します。
  • Prisma ORM バージョン 5.12.0 以降、ネストされた createMany は SQLite でサポートされています。
  • ネストされた create または ネストされた createMany を使用して、複数の関連レコードを作成できます - skipDuplicates クエリオプションが必要ない場合は、おそらく create を使用する必要があります。

オプション​

名前型必須説明
dataEnumerable<UserCreateManyInput>はい新しいレコードを作成するときに指定できるように、すべてのモデルフィールドを型でラップします。データモデルでオプションとしてマークされているフィールドまたはデフォルト値を持つフィールドはオプションです。
skipDuplicates?booleanいいえ一意のフィールドまたは既に存在するIDフィールドを持つレコードを挿入しません。ON CONFLICT DO NOTHINGをサポートするデータベースでのみサポートされています。これには、MongoDBとSQLServerは含まれません。

例​

User と複数の新しい関連 Post レコードを更新​
const user = await prisma.user.update({
  where: {
    id: 9,
  },
  data: {
    name: 'Elliott',
    posts: {
      createMany: {
        data: [{ title: 'My first post' }, { title: 'My second post' }],
      },
    },
  },
});

set​

set は、リレーションの値を上書きします。たとえば、Post レコードのリストを別のリストに置き換えます。参照：リレーションの操作

例​

以前の Post レコードをすべて切断し、他の 2 つの既存のレコードを接続して、既存の User レコードを更新​
const user = await prisma.user.update({
  where: { email: 'alice@prisma.io' },
  data: {
    posts: {
      set: [{ id: 32 }, { id: 42 }],
    },
  },
});

connect​

ネストされた connect クエリは、ID または一意の識別子を指定して、レコードを既存の関連レコードに接続します。参照：リレーションの操作

備考​

  • connect は、新しい親レコードを作成するか、既存の親レコードを更新するときに、ネストされたクエリとして使用できます。

  • 関連レコードが存在しない場合、Prisma Client は例外をスローします。

    The required connected records were not found. Expected 1 records to be connected, found 0.

  • set と connect を一緒に使用する場合、それらが適用される順序は結果に大きな影響を与えます。set が connect の前に使用される場合、接続されたレコードは、connect 操作によって確立された最終状態のみを反映します。これは、set が新しい接続を確立する前に既存の接続をすべてクリアするためです。逆に、connect が set の前に適用される場合、set 操作は、すべての接続されたレコードをクリアし、独自の指定された状態に置き換えることによって、connect アクションをオーバーライドします。

例​

一意のフィールドを介して、新しい Profile レコードを作成し、既存の User レコードに接続​
const user = await prisma.profile.create({
  data: {
    bio: 'Hello World',
    user: {
      connect: { email: 'alice@prisma.io' },
    },
  },
});
ID フィールドを介して、新しい Profile レコードを作成し、既存の User レコードに接続​
const user = await prisma.profile.create({
  data: {
    bio: 'Hello World',
    user: {
      connect: { id: 42 }, // sets userId of Profile record
    },
  },
});

2.11.0 以降では、外部キーを直接設定できます。

const user = await prisma.profile.create({
  data: {
    bio: 'Hello World',
    userId: 42,
  },
});

ただし、同じクエリで直接アプローチと connect アプローチの両方を使用することはできません。詳細については、この issue コメント を参照してください。

新しい Post レコードを作成し、既存の User レコードに接続​
const user = await prisma.post.create({
  data: {
    title: 'Hello World',
    author: {
      connect: { email: 'alice@prisma.io' },
    },
  },
});
既存の Profile レコードに接続して、既存の User レコードを更新​
const user = await prisma.user.update({
  where: { email: 'alice@prisma.io' },
  data: {
    profile: {
      connect: { id: 24 },
    },
  },
});
2 つの既存の Post レコードに接続して、既存の User レコードを更新​
const user = await prisma.user.update({
  where: { email: 'alice@prisma.io' },
  data: {
    posts: {
      connect: [{ id: 24 }, { id: 42 }],
    },
  },
});

connectOrCreate​

connectOrCreate は、ID または一意の識別子によってレコードを既存の関連レコードに接続するか、レコードが存在しない場合は新しい関連レコードを作成します。参照：リレーションの操作

備考​

  • 同時トランザクションとして実行される複数の connectOrCreate クエリは、競合状態を引き起こす可能性があります。次の例を考えてみましょう。2 つのクエリが同時に computing という名前のブログ投稿タグを connectOrCreate しようとしています（タグ名は一意である必要があります）。

    const createPost = await prisma.post.create({
      data: {
        title: 'How to create a compiler',
        content: '...',
        author: {
          connect: {
            id: 9,
          },
        },
        tags: {
          connectOrCreate: {
            create: {
              name: 'computing',
            },
            where: {
              name: 'computing',
            },
          },
        },
      },
    })

    クエリ A とクエリ B が次の方法で重複する場合、クエリ A は例外になります。

    クエリ A (失敗 ❌)クエリ B (成功 ✅)
    クエリがサーバーにヒットし、トランザクション A を開始クエリがサーバーにヒットし、トランザクション B を開始
    tagName が computing に等しいレコードを検索しますが、レコードが見つかりません。
    tagName が computing に等しいレコードを検索しますが、レコードが見つかりません。
    tagName が computing に等しいレコードを作成して接続します。
    tagName が computing に等しいレコードを作成します。
    一意性違反、レコードはトランザクション B によって既に作成されています。

    このシナリオを回避するために、一意性違反例外 (PrismaClientKnownRequestError、エラー P2002) をキャッチし、失敗したクエリを再試行することをお勧めします。

例​

新しい Profile レコードを作成し、既存の User レコードに接続するか、新しい User を作成​

次の例：

  1. Profile を作成します。
  2. プロファイルをメールアドレスが alice@prisma.io の User に接続しようとします。
  3. 一致するユーザーが存在しない場合は、新しいユーザーを作成します。
const user = await prisma.profile.create({
  data: {
    bio: 'The coolest Alice on the planet',
    user: {
      connectOrCreate: {
        where:  { email: 'alice@prisma.io' },
        create: { email: 'alice@prisma.io'}
    },
  },
})
新しい Post レコードを作成し、既存の User レコードに接続するか、新しい User を作成​
const user = await prisma.post.create({
  data: {
    title: 'Hello World',
    author: {
      connectOrCreate: {
        where: { email: 'alice@prisma.io' },
        create: { email: 'alice@prisma.io' },
      },
    },
  },
});
既存の Profile レコードに接続するか、新しい Profile レコードを作成して、既存の User レコードを更新​

次の例：

  1. ユーザーを id が 20 の Profile に接続しようとします。
  2. 一致するプロファイルが存在しない場合は、新しいプロファイルを作成します。
const updateUser = await prisma.user.update({
  where: { email: 'alice@prisma.io' },
  data: {
    profile: {
      connectOrCreate: {
        where: { id: 20 },
        create: {
          bio: 'The coolest Alice in town',
        },
      },
    },
  },
});
2 つの既存の Post レコードに接続するか、2 つの新しい Post レコードを作成して、既存の User レコードを更新​
const user = await prisma.user.update({
  where: { email: 'alice@prisma.io' },
  data: {
    posts: {
      connectOrCreate: [
        {
          where: { id: 32 },
          create: { title: 'This is my first post' },
        },
        {
          where: { id: 19 },
          create: { title: 'This is my second post' },
        },
      ],
    },
  },
});

disconnect​

ネストされた disconnect クエリは、親レコードと関連レコード間の接続を解除しますが、どちらのレコードも削除しません。参照：リレーションの操作

備考​

  • disconnect は、リレーションがオプションの場合にのみ使用できます。

  • 切断しようとしているリレーションシップが存在しない場合

    • (2.21.0 以降)、操作は何も行いません。

    • (2.21.0 より前) 提供された ID または一意の識別子が接続されていない場合、Prisma Client は例外をスローします。

      The records for relation `PostToUser` between the `User` and `Post` models are not connected.

例​

接続されている Profile レコードを切断して、既存の User レコードを更新​
const user = await prisma.user.update({
  where: { email: 'bob@prisma.io' },
  data: {
    profile: {
      disconnect: true,
    },
  },
});
接続されている 2 つの Post レコードを切断して、既存の User レコードを更新​
const user = await prisma.user.update({
  where: { email: 'alice@prisma.io' },
  data: {
    posts: {
      disconnect: [{ id: 44 }, { id: 46 }],
    },
  },
});

update​

ネストされた update クエリは、親レコードの ID が n である 1 つ以上の関連レコードを更新します。参照：リレーションの操作

備考​

  • ネストされた update クエリは、トップレベルの update クエリ (たとえば、prisma.user.update(...)) のコンテキストでのみ使用できます。

  • 親レコードが存在しない場合、Prisma Client は例外をスローします。

    AssertionError("Expected a valid parent ID to be present for nested update to-one case.")

  • 更新する関連レコードが存在しない場合、Prisma Client は例外をスローします。

    AssertionError("Expected a valid parent ID to be present for nested update to-one case.")

例​

接続されている Profile レコードを更新して、既存の User レコードを更新​
const user = await prisma.user.update({
  where: { email: 'alice@prisma.io' },
  data: {
    profile: {
      update: { bio: 'Hello World' },
    },
  },
});
接続されている 2 つの Post レコードを更新して、既存の User レコードを更新​
const user = await prisma.user.update({
  where: { email: 'alice@prisma.io' },
  data: {
    posts: {
      update: [
        {
          data: { published: true },
          where: { id: 32 },
        },
        {
          data: { published: true },
          where: { id: 23 },
        },
      ],
    },
  },
});

upsert​

情報

このセクションでは、update() 内のネストされた upsert の使用法について説明します。upsert() 操作の詳細については、リンク先のドキュメントを参照してください。

ネストされた upsert クエリは、関連レコードが存在する場合は更新し、存在しない場合は新しい関連レコードを作成します。

例​

接続されている Profile レコードを更新するか、新しいレコードを作成して、既存の User レコードを更新 (upsert)​
const user = await prisma.user.update({
  where: { email: 'alice@prisma.io' },
  data: {
    profile: {
      upsert: {
        create: { bio: 'Hello World' },
        update: { bio: 'Hello World' },
      },
    },
  },
});
接続されている 2 つの Post レコードを更新するか、新しいレコードを作成して、既存の User レコードを更新 (upsert)​
const user = await prisma.user.update({
  where: { email: 'alice@prisma.io' },
  data: {
    posts: {
      upsert: [
        {
          create: { title: 'This is my first post' },
          update: { title: 'This is my first post' },
          where: { id: 32 },
        },
        {
          create: { title: 'This is my second post' },
          update: { title: 'This is my second post' },
          where: { id: 23 },
        },
      ],
    },
  },
});

delete​

ネストされた delete クエリは、関連レコードを削除します。親レコードは削除されません。

備考​

  • delete は、リレーションがオプションの場合にのみ使用できます。

例​

接続されている Profile レコードを削除して、既存の User レコードを更新​
const user = await prisma.user.update({
  where: { email: 'alice@prisma.io' },
  data: {
    profile: {
      delete: true,
    },
  },
});
接続されている 2 つの Post レコードを削除して、既存の User レコードを更新​
const user = await prisma.user.update({
  where: { email: 'alice@prisma.io' },
  data: {
    posts: {
      delete: [{ id: 34 }, { id: 36 }],
    },
  },
});

updateMany​

ネストされた updateMany は、関連レコードのリストを更新し、フィルタリングをサポートします。たとえば、ユーザーの未公開の投稿を更新できます。

例​

特定のユーザーに属するすべての未公開投稿を更新​
const result = await prisma.user.update({
  where: {
    id: 2,
  },
  data: {
    posts: {
      updateMany: {
        where: {
          published: false,
        },
        data: {
          likes: 0,
        },
      },
    },
  },
});

deleteMany​

ネストされた deleteMany は、関連レコードを削除し、フィルタリングをサポートします。たとえば、ユーザーの他のプロパティを更新しながら、ユーザーの投稿を削除できます。

例​

更新の一部として特定のユーザーに属するすべての投稿を削除​
const result = await prisma.user.update({
  where: {
    id: 2,
  },
  data: {
    name: 'Updated name',
    posts: {
      deleteMany: {},
    },
  },
});

フィルター条件と演算子​

情報
  • バージョン 4.3.0 以降、これらの演算子を使用して、同じモデル内のフィールドを <model>.fields プロパティと比較することもできます。
  • 4.3.0 より前のバージョンでは、同じモデル内のフィールドを raw クエリと比較できます。

equals​

値が n と等しい。

例​

name が "Eleanor" と等しいすべてのユーザーを返す​
const result = await prisma.user.findMany({
  where: {
    name: {
      equals: 'Eleanor',
    },
  },
});

equals を省略することもできます。

const result = await prisma.user.findMany({
  where: {
    name: 'Eleanor',
  },
});
「警告数量」のしきい値よりも数量が少ないすべての製品を返す​

この例では、バージョン 4.3.0 以降で使用可能な同じモデルのフィールドを比較します。

const productsWithLowQuantity = await prisma.product.findMany({
  where: {
    quantity: {
      lte: prisma.product.fields.warnQuantity
    }
  },
});

not​

値が n と等しくない。

例​

name が "Eleanor" と等しくないすべてのユーザーを返す​
const result = await prisma.user.findMany({
  where: {
    name: {
      not: 'Eleanor',
    },
  },
});
警告

not は、指定された値に一致しないすべての項目を返します。ただし、列がnullableの場合、NULL 値は返されません。null値を返す必要がある場合は、OR 演算子を使用して NULL 値を含めます。

name が "Eleanor" と等しくないすべてのユーザーを、name が NULL のユーザーを含めて返す​
await prisma.user.findMany({
  where: {
    OR: [
      { name: { not: 'Eleanor' } },
      { name: null }
    ]
  }
})

in​

値 n がリストに存在する。

注記

null 値は返されません。たとえば、in と NOT を組み合わせて、名前がリストにないユーザーを返す場合、null 値の名前を持つユーザーは返されません。

例​

id が次のリスト [22, 91, 14, 2, 5] に見つかる User レコードを取得​
const getUser = await prisma.user.findMany({
  where: {
    id: { in: [22, 91, 14, 2, 5] },
  },
});
name が次のリスト ['Saqui', 'Clementine', 'Bob'] に見つかる User レコードを取得​
const getUser = await prisma.user.findMany({
  where: {
    name: { in: ['Saqui', 'Clementine', 'Bob'] },
  },
});
name がリストに存在しない User レコードを取得​

次の例では、in と NOT を組み合わせています。notIn を使用することもできます。

const getUser = await prisma.user.findMany({
  where: {
    NOT: {
      name: { in: ['Saqui', 'Clementine', 'Bob'] },
    },
  },
});
少なくとも 1 つの Post が少なくとも 1 つの指定された Category を持つ User レコードを取得​
const getUser = await prisma.user.findMany({
  where: {
    // Find users where..
    posts: {
      some: {
        // ..at least one (some) posts..
        categories: {
          some: {
            // .. have at least one category ..
            name: {
              in: ['Food', 'Introductions'], // .. with a name that matches one of the following.
            },
          },
        },
      },
    },
  },
});

notIn​

値 n がリストに存在しない。

備考​

  • null 値は返されません。

例​

id が次のリスト [22, 91, 14, 2, 5] に見つからない User レコードを取得​
const getUser = await prisma.user.findMany({
  where: {
    id: { notIn: [22, 91, 14, 2, 5] },
  },
});

lt​

値 n が x より小さい。

例​

likes が 9 より小さいすべての Post レコードを取得​
const getPosts = await prisma.post.findMany({
  where: {
    likes: {
      lt: 9,
    },
  },
});

lte​

値 n が x 以下。

例​

likes が 9 以下のすべての Post レコードを取得​
const getPosts = await prisma.post.findMany({
  where: {
    likes: {
      lte: 9,
    },
  },
});

gt​

値 n が x より大きい。

例​

likes が 9 より大きい Post レコードをすべて取得する​
const getPosts = await prisma.post.findMany({
  where: {
    likes: {
      gt: 9,
    },
  },
});

gte​

値 n が x より大きいかまたは等しい。

例​

likes が 9 以上の Post レコードをすべて取得する​
const getPosts = await prisma.post.findMany({
  where: {
    likes: {
      gte: 9,
    },
  },
});

例​

date_created が 2020 年 3 月 19 日より後の Post レコードをすべて取得する​
const result = await prisma.post.findMany({
  where: {
    date_created: {
      gte: new Date('2020-03-19T14:21:00+0200') /* Includes time offset for UTC */,
    },
  },
});

contains​

値 n が x を含む。

例​

content が databases を含む Post レコードをすべてカウントする​
const result = await prisma.post.count({
  where: {
    content: {
      contains: 'databases',
    },
  },
});
content が databases を含まない Post レコードをすべてカウントする​
const result = await prisma.post.count({
  where: {
    NOT: {
      content: {
        contains: 'databases',
      },
    },
  },
});

String フィールド内を検索するには、フルテキスト検索を使用してください。

情報

PostgreSQL の場合、この機能はまだプレビュー段階です。使用するには、fullTextSearchPostgres 機能フラグを有効にしてください。

例​

タイトルに cat または dog を含むすべての投稿を検索する。​
const result = await prisma.post.findMany({
  where: {
    title: {
      search: 'cat | dog',
    },
  },
});
タイトルに cat と dog の両方を含むすべての投稿を検索する。​
const result = await prisma.post.findMany({
  where: {
    title: {
      search: 'cat & dog',
    },
  },
});
タイトルに cat を含まないすべての投稿を検索する。​
const result = await prisma.post.findMany({
  where: {
    title: {
      search: '!cat',
    },
  },
});

mode​

注釈​

  • PostgreSQL および MongoDB コネクタのみでサポートされています

例​

大文字と小文字を区別しない方法で、title に prisma を含む Post レコードをすべて取得する​
const result = await prisma.post.findMany({
  where: {
    title: {
      contains: 'prisma',
      mode: 'insensitive',
    },
  },
});

startsWith​

例​

title が Pr で始まる（Prisma など）Post レコードをすべて取得する​
const result = await prisma.post.findMany({
  where: {
    title: {
      startsWith: 'Pr',
    },
  },
});

endsWith​

email が prisma.io で終わる User レコードをすべて取得する​

const result = await prisma.user.findMany({
  where: {
    email: {
      endsWith: 'prisma.io',
    },
  },
});

AND​

すべての条件が true を返す必要があります。または、where 句にオブジェクトのリストを渡します - AND 演算子は不要です。

例​

content フィールドに Prisma が含まれ、published が false である Post レコードをすべて取得する​
const result = await prisma.post.findMany({
  where: {
    AND: [
      {
        content: {
          contains: 'Prisma',
        },
      },
      {
        published: {
          equals: false,
        },
      },
    ],
  },
});
content フィールドに Prisma が含まれ、published が false である Post レコードをすべて取得する（AND なし）​

次の形式は、AND 演算子なしで前の例と同じ結果を返します

const result = await prisma.post.findMany({
  where: {
    content: {
      contains: 'Prisma',
    },
    published: {
      equals: false,
    },
  },
});
title フィールドに Prisma または databases が含まれ、published が false である Post レコードをすべて取得する​

次の例は、OR と AND を組み合わせたものです

const result = await prisma.post.findMany({
  where: {
    OR: [
      {
        title: {
          contains: 'Prisma',
        },
      },
      {
        title: {
          contains: 'databases',
        },
      },
    ],
    AND: {
      published: false,
    },
  },
});

OR​

1 つ以上の条件が true を返す必要があります。

例​

title フィールドに Prisma または databases が含まれる Post レコードをすべて取得する​
const result = await prisma.post.findMany({
  where: {
    OR: [
      {
        title: {
          contains: 'Prisma',
        },
      },
      {
        title: {
          contains: 'databases',
        },
      },
    ],
  },
});
title フィールドに Prisma または databases が含まれるが、SQL は含まれない Post レコードをすべて取得する​

次の例は、OR と NOT を組み合わせたものです

const result = await prisma.post.findMany({
  where: {
    OR: [
      {
        title: {
          contains: 'Prisma',
        },
      },
      {
        title: {
          contains: 'databases',
        },
      },
    ],
    NOT: {
      title: {
        contains: 'SQL',
      },
    },
  },
});
title フィールドに Prisma または databases が含まれ、published が false である Post レコードをすべて取得する​

次の例は、OR と AND を組み合わせたものです

const result = await prisma.post.findMany({
  where: {
    OR: [
      {
        title: {
          contains: 'Prisma',
        },
      },
      {
        title: {
          contains: 'databases',
        },
      },
    ],
    AND: {
      published: false,
    },
  },
});

NOT​

すべての条件が false を返す必要があります。

例​

title に SQL を含まない Post レコードをすべて取得する​
const result = await prisma.post.findMany({
  where: {
    NOT: {
      title: {
        contains: 'SQL',
      },
    },
  },
});
title フィールドに Prisma または databases が含まれるが、SQL は含まれず、関連する User レコードのメールアドレスに sarah が含まれない Post レコードをすべて取得する​
const result = await prisma.post.findMany({
  where: {
    OR: [
      {
        title: {
          contains: 'Prisma',
        },
      },
      {
        title: {
          contains: 'databases',
        },
      },
    ],
    NOT: {
      title: {
        contains: 'SQL',
      },
    },
    user: {
      NOT: {
        email: {
          contains: 'sarah',
        },
      },
    },
  },
  include: {
    user: true,
  },
});

リレーションフィルター​

some​

1 つ以上 (「some」) の関連レコードがフィルタリング条件に一致するすべてのレコードを返します。

注釈​

  • パラメータなしで some を使用して、少なくとも 1 つのリレーションを持つすべてのレコードを返すことができます

例​

一部の投稿で Prisma に言及している User レコードをすべて取得する​
const result = await prisma.user.findMany({
  where: {
    post: {
      some: {
        content: {
          contains: "Prisma"
        }
      }
    }
  }
}

every​

すべて (「every」) の関連レコードがフィルタリング条件に一致するすべてのレコードを返します。

例​

すべての投稿が公開されている User レコードをすべて取得する​
const result = await prisma.user.findMany({
  where: {
    post: {
      every: {
        published: true
      },
    }
  }
}

none​

ゼロの関連レコードがフィルタリング条件に一致するすべてのレコードを返します。

注釈​

例​

投稿がゼロの User レコードをすべて取得する​
const result = await prisma.user.findMany({
  where: {
    post: {
        none: {} // User has no posts
    }
  }
}
公開された投稿がゼロの User レコードをすべて取得する​
const result = await prisma.user.findMany({
  where: {
    post: {
        none: {
          published: true
        }
    }
  }
}

is​

関連レコードがフィルタリング条件に一致するすべてのレコードを返します（例：ユーザーの名前が is Bob）。

例​

ユーザーの名前が "Bob" である Post レコードをすべて取得する​
const result = await prisma.post.findMany({
  where: {
    user: {
        is: {
          name: "Bob"
        },
    }
  }
}

isNot​

関連レコードがフィルタリング条件に一致しないすべてのレコードを返します（例：ユーザーの名前が isNot Bob）。

例​

ユーザーの名前が "Bob" ではない Post レコードをすべて取得する​
const result = await prisma.post.findMany({
  where: {
    user: {
        isNot: {
          name: "Bob"
        },
    }
  }
}

スカラーリストメソッド​

set​

set を使用して、スカラーリストフィールドの値を上書きします。

注釈​

  • set はオプションです - 値を直接設定できます

    tags: ['computers', 'books'];

例​

tags の値を文字列値のリストに設定する​
const setTags = await prisma.post.update({
  where: {
    id: 9,
  },
  data: {
    tags: {
      set: ['computing', 'books'],
    },
  },
});
set キーワードを使用せずに、tags を値のリストに設定する​
const setTags = await prisma.post.update({
  where: {
    id: 9,
  },
  data: {
    tags: ['computing', 'books'],
  },
});

tags の値を単一の文字列値に設定する​

const setTags = await prisma.post.update({
  where: {
    id: 9,
  },
  data: {
    tags: {
      set: 'computing',
    },
  },
});

push​

push はバージョン 2.20.0 以降で利用可能です。push を使用して、1 つの値または複数の値をスカラーリストフィールドに追加します。

注釈​

  • PostgreSQL および MongoDB でのみ利用可能です。
  • 値のリストまたは単一の値のみをプッシュできます。

例​

computing アイテムを tags リストに追加する​
const addTag = await prisma.post.update({
  where: {
    id: 9,
  },
  data: {
    tags: {
      push: 'computing',
    },
  },
});
const addTag = await prisma.post.update({
  where: {
    id: 9,
  },
  data: {
    tags: {
      push: ['computing', 'genetics'],
    },
  },
});

unset​

警告

このメソッドは、バージョン 3.11.1 以降の MongoDB でのみ利用可能です。

unset を使用して、スカラーリストの値を設定解除します。set: null とは異なり、unset はリスト全体を完全に削除します。

例​

tags の値を設定解除する​
const setTags = await prisma.post.update({
  where: {
    id: 9,
  },
  data: {
    tags: {
      unset: true,
    },
  },
});

スカラーリストフィルター​

スカラーリストフィルターを使用すると、リスト/配列フィールドの内容でフィルタリングできます。

警告

利用可能なデータベース:

  • バージョン 2.15.0 以降の PostgreSQL
  • バージョン 3.9.0 以降の CockroachDB
  • バージョン 3.11.0 以降の MongoDB

注釈​

  • スカラーリスト/配列フィルターは、NULL 値を無視します。 isEmpty または NOT を使用しても、NULL 値リスト/配列を持つレコードは返されず、{ equals: null } を使用するとエラーが発生します。

has​

指定された値がリストに存在します。

例​

次のクエリは、tags リストに "databases" が含まれるすべての Post レコードを返します

const posts = await client.post.findMany({
  where: {
    tags: {
      has: 'databases',
    },
  },
});

次のクエリは、tags リストに "databases" が含まれないすべての Post レコードを返します

const posts = await client.post.findMany({
  where: {
    NOT: {
      tags: {
        has: 'databases',
      },
    },
  },
});

hasEvery​

すべての値がリストに存在します。

例​

次のクエリは、tags リストに少なくとも "databases" と "typescript" の両方が含まれるすべての Post レコードを返します

const posts = await prisma.post.findMany({
  where: {
    tags: {
      hasEvery: ['databases', 'typescript'],
    },
  },
});

hasSome​

少なくとも 1 つの値がリストに存在します。

例​

次のクエリは、tags リストに "databases" または "typescript" が含まれるすべての Post レコードを返します

const posts = await prisma.post.findMany({
  where: {
    tags: {
      hasSome: ['databases', 'typescript'],
    },
  },
});

isEmpty​

リストが空です。

例​

次のクエリは、タグがないすべての Post レコードを返します

const posts = await prisma.post.findMany({
  where: {
    tags: {
      isEmpty: true,
    },
  },
});

isSet​

警告

このフィルターは、バージョン 3.11.1 以降の MongoDB でのみ利用可能です。

リストをフィルタリングして、設定されている結果のみを含めます（値が設定されているか、明示的に null に設定されているかのいずれか）。このフィルターを true に設定すると、まったく設定されていない未定義の結果は除外されます。

例​

次のクエリは、tags が null または値のいずれかに設定されているすべての Post レコードを返します

const posts = await prisma.post.findMany({
  where: {
    tags: {
      isSet: true,
    },
  },
});

equals​

リストが指定された値と完全に一致します。

例​

次のクエリは、tags リストに "databases" と "typescript" のみを含むすべての Post レコードを返します

const posts = await prisma.post.findMany({
  where: {
    tags: {
      equals: ['databases', 'typescript'],
    },
  },
});

複合型メソッド​

警告

Prisma 3.10.0 以降の MongoDB でのみ利用可能です。

複合型メソッドを使用すると、複合型の作成、更新、および削除を行うことができます。

set​

set を使用して、複合型の値を上書きします。

注釈​

  • set キーワードはオプションです - 値を直接設定できます 
    photos: [
      { height: 100, width: 200, url: '1.jpg' },
      { height: 100, width: 200, url: '2.jpg' },
    ];

例​

新しい order 内に shippingAddress 複合型を設定する​
const order = await prisma.order.create({
  data: {
    // Normal relation
    product: { connect: { id: 'some-object-id' } },
    color: 'Red',
    size: 'Large',
    // Composite type
    shippingAddress: {
      set: {
        street: '1084 Candycane Lane',
        city: 'Silverlake',
        zip: '84323',
      },
    },
  },
});
オプションの複合型を null に設定する​
const order = await prisma.order.create({
  data: {
    // Embedded optional type, set to null
    billingAddress: {
      set: null,
    },
  },
});

unset​

unset を使用して、複合型の値を設定解除します。set: null とは異なり、これは MongoDB ドキュメントからフィールド全体を削除します。

例​

order から billingAddress を削除する​
const order = await prisma.order.update({
  where: {
    id: 'some-object-id',
  },
  data: {
    billingAddress: {
      // Unset the billing address
      // Removes "billingAddress" field from order
      unset: true,
    },
  },
});

update​

update を使用して、必須の複合型内のフィールドを更新します。

注釈​

update メソッドは、オプション型では使用できません。代わりに、upsert を使用してください

例​

shippingAddress 複合型の zip フィールドを更新する​
const order = await prisma.order.update({
  where: {
    id: 'some-object-id',
  },
  data: {
    shippingAddress: {
      // Update just the zip field
      update: {
        zip: '41232',
      },
    },
  },
});

upsert​

upsert を使用して、既存のオプションの複合型が存在する場合は更新し、それ以外の場合は複合型を設定します。

注釈​

upsert メソッドは、必須型では使用できません。代わりに、update を使用してください

例​

billingAddress が存在しない場合は新しく作成し、それ以外の場合は更新する​
const order = await prisma.order.update({
  where: {
    id: 'some-object-id',
  },
  data: {
    billingAddress: {
      // Create the address if it doesn't exist,
      // otherwise update it
      upsert: {
        set: {
          street: '1084 Candycane Lane',
          city: 'Silverlake',
          zip: '84323',
        },
        update: {
          zip: '84323',
        },
      },
    },
  },
});

push​

push を使用して、複合型のリストの最後に値をプッシュします。

例​

新しい写真を photos リストに追加する​
const product = prisma.product.update({
  where: {
    id: 10,
  },
  data: {
    photos: {
      // Push a photo to the end of the photos list
      push: [{ height: 100, width: 200, url: '1.jpg' }],
    },
  },
});

複合型フィルター​

警告

Prisma 3.11.0 以降の MongoDB でのみ利用可能です。

複合型フィルターを使用すると、複合型の内容をフィルタリングできます。

equals​

equals を使用して、複合型または複合型リストを一致させることで結果をフィルタリングします。複合型のすべての必須フィールドが一致する必要があります。

注釈​

オプションフィールドを一致させる場合、ドキュメントの未定義（欠落）フィールドと、明示的に null に設定されているフィールドを区別する必要があります

  • オプションフィールドを省略すると、未定義のフィールドには一致しますが、null に設定されているフィールドには一致しません
  • equals: { ... exampleField: null ... } を使用してオプションフィールドの null 値をフィルタリングすると、フィールドが null に設定されているドキュメントのみが一致し、未定義のフィールドは一致しません

equals を使用する場合、フィールドとリストの順序が重要です

  • フィールドの場合、{ "a": "1", "b": "2" } と { "b": "2", "a": "1" } は等しいとはみなされません
  • リストの場合、[ { "a": 1 }, { "a": 2 } ] と [ { "a": 2 }, { "a": 1 } ] は等しいとはみなされません

例​

指定された shippingAddress と完全に一致する注文を検索する​
const orders = await prisma.order.findMany({
  where: {
    shippingAddress: {
      equals: {
        street: '555 Candy Cane Lane',
        city: 'Wonderland',
        zip: '52337',
      },
    },
  },
});
URL のリストのすべてに一致する写真を持つ製品を検索する​
const product = prisma.product.findMany({
  where: {
    equals: {
      photos: [{ url: '1.jpg' }, { url: '2.jpg' }],
    },
  },
});

is​

is を使用して、複合型内の特定のフィールドを一致させることで結果をフィルタリングします。

例​

指定されたstreet名に一致する shippingAddress を持つ注文を検索する​
const orders = await prisma.order.findMany({
  where: {
    shippingAddress: {
      is: {
        street: '555 Candy Cane Lane',
      },
    },
  },
});

isNot​

isNot を使用して、一致しない複合型フィールドの結果をフィルタリングします。

例​

指定されたzipコードに一致しない shippingAddress を持つ注文を検索する​
const orders = await prisma.order.findMany({
  where: {
    shippingAddress: {
      isNot: {
        zip: '52337',
      },
    },
  },
});

isEmpty​

isEmpty を使用して、複合型の空のリストの結果をフィルタリングします。

例​

写真がない製品を検索する​
const product = prisma.product.findMany({
  where: {
    photos: {
      isEmpty: true,
    },
  },
});

every​

every を使用して、リスト内のすべての項目が条件に一致する複合型のリストをフィルタリングします

例​

すべての写真の height が 200 である最初の製品を検索する​
const product = await prisma.product.findFirst({
  where: {
    photos: {
      every: {
        height: 200,
      }
    }
  },
})

some​

some を使用して、リスト内の 1 つ以上の項目が条件に一致する複合型のリストをフィルタリングします。

例​

1 つ以上の写真の url が 2.jpg である最初の製品を検索する​
const product = await prisma.product.findFirst({
  where: {
    photos: {
      some: {
         url: "2.jpg",
      }
    }
  },
})

none​

none を使用して、リスト内のどの項目も条件に一致しない複合型のリストをフィルタリングします。

例​

どの写真の url も 2.jpg ではない最初の製品を検索する​
const product = await prisma.product.findFirst({
  where: {
    photos: {
      none: {
         url: "2.jpg",
      }
    }
  },
})

アトミックな数値演算​

更新時のアトミック演算は、数値型フィールド（Float および Int）で利用可能です。この機能を使用すると、競合状態のリスクなしに、フィールドの現在の値に基づいてフィールドを更新（減算や除算など）できます。

概要：競合状態

レースコンディション（競合状態）は、タスクを完了するために2つ以上の操作を順番に実行する必要がある場合に発生します。以下の例では、2つのクライアントが同じフィールド（postCount）を1ずつ増やそうとしています。

クライアント操作値
クライアント 1フィールド値を取得21
クライアント 2フィールド値を取得21
クライアント 2フィールド値を設定22
クライアント 1フィールド値を設定22 ✘

本来の値は23であるはずですが、2つのクライアントがpostCountフィールドへの読み取りと書き込みを順番に行いませんでした。更新に対するアトミック操作は、読み取りと書き込みを単一の操作に結合することで、レースコンディションを防ぎます。

クライアント操作値
クライアント 1フィールド値を取得および設定21 → 22
クライアント 2フィールド値を取得および設定22 → 23 ✔

オペレーター​

オプション説明
increment（インクリメント）現在の値にnを加算します。
decrement（デクリメント）現在の値からnを減算します。
multiply（乗算）現在の値にnを乗算します。
divide（除算）現在の値をnで除算します。
set（設定）現在のフィールド値を設定します。{ myField : n }と同じです。

注記​

  • クエリごとに、フィールドあたり1つのアトミック更新のみを実行できます。
  • フィールドがnullの場合、increment、decrement、multiply、またはdivideによって更新されることはありません。

例​

すべてのPostレコードのすべてのviewおよびlikesフィールドを1ずつインクリメントします​

const updatePosts = await prisma.post.updateMany({
  data: {
    views: {
      increment: 1,
    },
    likes: {
      increment: 1,
    },
  },
});

すべてのPostレコードのすべてのviewsフィールドを0に設定します​

const updatePosts = await prisma.post.updateMany({
  data: {
    views: {
      set: 0,
    },
  },
});

次のようにも記述できます

const updatePosts = await prisma.post.updateMany({
  data: {
    views: 0,
  },
});

Jsonフィルター​

ユースケースと高度な例については、Jsonフィールドの操作を参照してください。

警告

PostgreSQLおよびMySQLでサポートされていますが、pathオプションの構文が異なります。PostgreSQLは、配列内のオブジェクトキー値のフィルタリングをサポートしていません。

このセクションの例は、petフィールドの値が以下であることを前提としています

{
  "favorites": {
    "catBreed": "Turkish van",
    "dogBreed": "Rottweiler",
    "sanctuaries": ["RSPCA", "Alley Cat Allies"],
    "treats": [
      { "name": "Dreamies", "manufacturer": "Mars Inc" },
      { "name": "Treatos", "manufacturer": "The Dog People" }
    ]
  },
  "fostered": {
    "cats": ["Bob", "Alice", "Svetlana the Magnificent", "Queenie"]
  },
  "owned": {
    "cats": ["Elliott"]
  }
}

注記​

path​

pathは、特定のキーの場所を表します。次のクエリは、ネストされたfavourites > dogBreedキーが"Rottweiler"と等しいすべてのユーザーを返します。

const getUsers = await prisma.user.findMany({
  where: {
    pets: {
      path: ['favorites', 'dogBreed'],
      equals: 'Rottweiler',
    },
  },
});

次のクエリは、ネストされたowned > cats配列に"Elliott"が含まれているすべてのユーザーを返します。

const getUsers = await prisma.user.findMany({
  where: {
    pets: {
      path: ['owned', 'cats'],
      array_contains: ['Elliott'],
    },
  },
});
警告

配列内のオブジェクトのキー値によるフィルタリング（下記）は、MySQLコネクタでのみサポートされています。

次のクエリは、ネストされたfavorites > treats配列に、name値が"Dreamies"であるオブジェクトが含まれているすべてのユーザーを返します

const getUsers = await prisma.user.findMany({
  where: {
    pets: {
      path: '$.favorites.treats[*].name',
      array_contains: 'Dreamies',
    },
  },
});

string_contains​

次のクエリは、ネストされたfavorites > catBreedキー値に"Van"が含まれているすべてのユーザーを返します

const getUsers = await prisma.user.findMany({
  where: {
    pets: {
      path: ['favorites', 'catBreed'],
      string_contains: 'Van',
    },
  },
});

string_starts_with​

次のクエリは、ネストされたfavorites > catBreedキー値が"Turkish"で始まるすべてのユーザーを返します

const getUsers = await prisma.user.findMany({
  where: {
    pets: {
      path: ['favorites', 'catBreed'],
      string_starts_with: 'Turkish',
    },
  },
});

string_ends_with​

次のクエリは、ネストされたfavorites > catBreedキー値が"Van"で終わるすべてのユーザーを返します

const getUsers = await prisma.user.findMany({
  where: {
    pets: {
      path: ['favorites', 'catBreed'],
      string_ends_with: 'Van',
    },
  },
});

mode​

文字列フィルタリングで大文字と小文字を区別するか（デフォルト）、区別しないかを指定します。

次のクエリは、ネストされたfavorites > catBreedキー値に"Van"または"van"が含まれているすべてのユーザーを返します

const getUsers = await prisma.user.findMany({
  where: {
    pets: {
      path: ['favorites', 'catBreed'],
      string_contains: 'Van',
      mode: "insensitive",
    },
  },
});

array_contains​

次のクエリは、sanctuaries配列に値"RSPCA"が含まれているすべてのユーザーを返します

const getUsers = await prisma.user.findMany({
  where: {
    pets: {
      path: ['sanctuaries'],
      array_contains: ['RSPCA'],
    },
  },
});
情報

注: PostgreSQLでは、array_containsの値は、配列に単一の値しか含まれていない場合でも、文字列ではなく配列である必要があります。

次のクエリは、sanctuaries配列に指定された配列内のすべての値が含まれているすべてのユーザーを返します

const getUsers = await prisma.user.findMany({
  where: {
    pets: {
      path: ['sanctuaries'],
      array_contains: ['RSPCA', 'Alley Cat Allies'],
    },
  },
});

array_starts_with​

次のクエリは、sanctuaries配列が値"RSPCA"で始まるすべてのユーザーを返します

const getUsers = await prisma.user.findMany({
  where: {
    pets: {
      path: ['sanctuaries'],
      array_starts_with: 'RSPCA',
    },
  },
});

array_ends_with​

次のクエリは、sanctuaries配列が値"Alley Cat Allies"で終わるすべてのユーザーを返します

const getUsers = await prisma.user.findMany({
  where: {
    pets: {
      path: ['sanctuaries'],
      array_ends_with: 'Alley Cat Allies',
    },
  },
});

クライアントメソッド​

注: クライアントレベルのメソッドには、$がプレフィックスとして付いています。

注記​

  • $onおよび$useクライアントメソッドは、$extendsを使用して拡張された拡張クライアントインスタンスには存在しません
警告

拡張クライアントでは、クライアントメソッドが必ずしも存在するとは限りません。クライアントを拡張する場合は、$transactionや$connectなどのクライアントメソッドを使用する前に、存在を確認してください。

さらに、$onまたは$useを使用している場合は、これらのクライアントメソッドをクライアントを拡張する前に使用する必要があります。これらのメソッドは拡張クライアントには存在しないためです。特に$useについては、クエリ拡張の使用に移行することをお勧めします。

$disconnect()​

$disconnect()メソッドは、$connectが呼び出されたときに確立されたデータベース接続を閉じ、Prisma ORMのクエリエンジンを実行していたプロセスを停止します。$connect()と$disconnect()の概要については、接続管理を参照してください。

注記​

  • $disconnect()はPromiseを返すため、async関数内でawaitキーワードとともに呼び出す必要があります。

$connect()​

$connect()メソッドは、Prisma ORMのクエリエンジンを介してデータベースへの物理接続を確立します。$connect()と$disconnect()の概要については、接続管理を参照してください。

注記​

  • $connect()はPromiseを返すため、async関数内でawaitキーワードとともに呼び出す必要があります。

$on()​

警告

$onは拡張クライアントでは使用できません。クライアント拡張に移行するか、クライアントを拡張する前に$onメソッドを使用してください。

$on()メソッドを使用すると、ログイベントまたは終了フックをサブスクライブできます。

$use()​

警告

$useは拡張クライアントでは使用できません。クエリ拡張に移行するか、クライアントを拡張する前に$useメソッドを使用してください。

$use()メソッドはミドルウェアを追加します

prisma.$use(async (params, next) => {
  console.log('This is middleware!');
  // Modify or interrogate params here

  return next(params);
});

next​

nextはミドルウェアスタックの「次のレベル」を表します。これは、スタック内のどこにいるかに応じて、次のミドルウェアまたはPrismaクエリである可能性があります。

params​

paramsは、ミドルウェアで使用する情報を含むオブジェクトです。

パラメーター説明
action（アクション）クエリタイプ - 例：createまたはfindMany。
args（引数）クエリに渡された引数 - 例：where、data、またはorderBy
dataPath（データパス）fluent APIを使用する場合に設定されます。
model（モデル）モデルタイプ - 例：PostまたはUser。
runInTransaction（トランザクション内で実行）クエリがトランザクションのコンテキストで実行された場合はtrueを返します。
ヒント

modelプロパティを文字列として使用する必要がある場合は、String(params.model)を使用してください

パラメーター値の例

{
  args: { where: { id: 15 } },
  dataPath: [ 'select', 'author', 'select', 'posts' ],
  runInTransaction: false,
  action: 'findMany',
  model: 'Post'
}

例​

ミドルウェアの例を参照してください。

$queryRawTyped​

参照: Raw SQLの使用 ($queryRawTyped)。

$queryRaw​

参照: Raw SQLの使用 ($queryRaw)。

$queryRawUnsafe()​

参照: Raw SQLの使用 ($queryRawUnsafe())。

$executeRaw​

参照: Raw SQLの使用 ($executeRaw)。

$executeRawUnsafe()​

参照: Raw SQLの使用 ($executeRawUnsafe())。

$runCommandRaw()​

参照: Raw SQLの使用 ($runCommandRaw())。

$transaction()​

参照: トランザクション。

$metrics​

Prisma Clientメトリクスは、Prisma Clientがデータベースとどのように対話するかについての詳細な洞察を提供します。この洞察を使用して、アプリケーションのパフォーマンスの問題を診断できます。詳細: メトリクス。

Prisma Clientメトリクスには、次のメソッドがあります

$extends​

$extendsを使用すると、Prisma Client拡張機能を作成および使用して、次の方法でPrisma Clientに機能を追加できます

  • model: モデルにカスタムメソッドを追加
  • client: クライアントにカスタムメソッドを追加
  • query: カスタムPrisma Clientクエリを作成
  • result: クエリ結果にカスタムフィールドを追加

詳細: Prisma Client拡張機能。

ユーティリティ型​

ユーティリティ型は、Prisma名前空間に存在するヘルパー関数と型です。これらは、アプリケーションの型安全性を維持するのに役立ちます。

Prisma.validator​

validatorは、作成するオブジェクトが有効であることを保証しながら、スキーマモデルに基づいて再利用可能なクエリパラメーターを作成するのに役立ちます。以下も参照してください: Prisma.validatorの使用

validatorを使用するには、2つの方法があります

生成されたPrisma Client型を使用する​

型を使用すると、データ検証への型レベルのアプローチが提供されます

Prisma.validator<GeneratedType>({ args });

「セレクター」を使用する​

セレクターパターンを使用する場合、既存のPrisma Clientインスタンスを使用してバリデーターを作成します。このパターンを使用すると、検証対象のモデル、操作、およびクエリオプションを選択できます。

Prisma Client拡張機能を使用して拡張されたPrisma Clientのインスタンスも使用できます。

Prisma.validator(PrismaClientInstance, '<model>', '<operation>', '<query option>')({ args });

例​

次の例は、アプリ内で再利用できるcreate操作の入力を抽出して検証する方法を示しています

import { Prisma } from '@prisma/client';

const validateUserAndPostInput = (name, email, postTitle) => {
  return Prisma.validator<Prisma.UserCreateInput>()({
    name,
    email,
    posts: {
      create: {
        title: postTitle,
      },
    },
  });
};

同じ操作の代替構文を次に示します

import { Prisma } from '@prisma/client';
import prisma from './prisma';

const validateUserAndPostInput = (name, email, postTitle) => {
  return Prisma.validator(
    prisma,
    'user',
    'create',
    'data'
  )({
    name,
    email,
    posts: {
      create: {
        title: postTitle,
      },
    },
  });
};

同じテーブル内の列を比較する​

一意でないフィルターの場合、同じテーブル内の列を直接比較できます。

この機能はバージョン5.0.0で一般提供になり、Prisma ORMバージョン4.3.0から4.16.2まではfieldReferenceプレビュー機能を通じて利用可能でした。

情報

次の状況では、Rawクエリを使用して同じテーブル内の列を比較する必要があります

  • 4.3.0より前のバージョンを使用する場合
  • findUniqueまたはfindUniqueOrThrowなど、一意のフィルターを使用する場合
  • 一意制約を持つフィールドを比較する場合
  • MySQLまたはMariaDBのJSONフィールドを別のフィールドと比較するために、次のオペレーターのいずれかを使用する場合: gt、gte、lt、またはlte。これらのオペレーターを使用してJSONフィールドをスカラー値と比較できることに注意してください。この制限は、JSONフィールドを別のフィールドと比較しようとする場合にのみ適用されます。

同じテーブル内の列を比較するには、<model>.fieldsプロパティを使用します。次の例では、クエリはprisma.product.quantityフィールドの値がprisma.product.warnQuantityフィールドの値以下であるすべてのレコードを返します。

prisma.product.findMany({
  where: { quantity: { lte: prisma.product.fields.warnQuantity } },
});
情報

fieldsは、すべてのモデルの特別なプロパティです。これには、そのモデルのフィールドのリストが含まれています。

考慮事項​

フィールドは同じ型である必要があります​

同じ型のフィールドでのみ比較できます。たとえば、次はエラーを引き起こします

await prisma.order.findMany({
  where: {
    id: { equals: prisma.order.fields.due },
    // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    // Type error: id is a string, while amountDue is an integer
  },
});

フィールドは同じモデル内にある必要があります​

同じモデル内のフィールドのfieldsプロパティでのみ比較できます。次の例は機能しません

await prisma.order.findMany({
  where: {
    id: { equals: prisma.user.fields.name },
    // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    // Type error: name is a field on the User model, not Order
  },
});

ただし、標準クエリを使用して、異なるモデルのフィールドを比較できます。

groupByモデルクエリでは、参照フィールドをby引数に入れます​

groupByモデルクエリをhavingオプションで使用する場合、参照フィールドをby引数に入れる必要があります。

次の例は機能します

prisma.user.groupBy({
  by: ['id', 'name'],
  having: { id: { equals: prisma.user.fields.name } },
});

次の例は機能しません。nameがby引数に含まれていないためです

prisma.user.groupBy({
  by: ['id'],
  having: { id: { equals: prisma.user.fields.name } },
  // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  // name is not in the 'by' argument
});

スカラーリスト内のフィールドを検索する​

データソースがスカラーリストをサポートしている場合（たとえばPostgreSQL）、特定のフィールドがフィールドリスト内にあるすべてのレコードを検索できます。これを行うには、inおよびnotInフィルターを使用してスカラーリストを参照します。例:

await prisma.user.findMany({
  where: {
    // find all users where 'name' is in a list of tags
    name: { in: prisma.user.fields.tags },
  },
});

UserWhereUniqueInputで一意でないフィールドをフィルタリングする​

バージョン5.0.0以降、whereの生成された型UserWhereUniqueInputは、一意のフィールドだけでなく、モデル上のすべてのフィールドを公開します。これは、バージョン4.5.0から4.16.2までのextendedWhereUniqueプレビューフラグの下で利用可能でした

whereステートメントでは、ブール演算子の外側に少なくとも1つの一意のフィールドを指定する必要があり、追加の一意および一意でないフィールドを任意の数だけ指定できます。これを使用して、単一のレコードを返す任意の操作にフィルターを追加できます。たとえば、この機能は次の場合に使用できます

バージョン4.6.0以降、この機能を使用して、オプションの1対1のネストされた読み取りをフィルタリングできます。

更新の楽観的同時実行制御​

一意でないフィールドをフィルタリングして、update操作で楽観的同時実行制御を実行できます。

楽観的同時実行制御を実行するには、versionフィールドを使用して、コードの実行中にレコードまたは関連レコードのデータが変更されたかどうかを確認することをお勧めします。バージョン4.5.0より前では、versionフィールドは一意でないため、update操作でversionフィールドを評価できませんでした。バージョン4.5.0以降では、versionフィールドを評価できます。

次の例では、updateOneとupdateTwoは最初に同じレコードを読み取り、次に更新を試みます。データベースは、versionの値が最初の読み取り時の値と同じ場合にのみ、これらの更新を実行します。データベースがこれらの更新の最初（タイミングに応じてupdateOneまたはupdateTwoのいずれか）を実行すると、versionの値がインクリメントされます。これは、versionの値が変更されたため、データベースが2回目の更新を実行しないことを意味します。

model User {
  id      Int    @id @default(autoincrement())
  email   String @unique
  city    String
  version Int
}
function updateOne() {
  const user = await prisma.user.findUnique({ id: 1 });

  await prisma.user.update({
    where: { id: user.id, version: user.version },
    data: { city: 'Berlin', version: { increment: 1 } },
  });
}

function updateTwo() {
  const user = await prisma.user.findUnique({ id: 1 });

  await prisma.user.update({
    where: { id: user.id, version: user.version },
    data: { city: 'New York', version: { increment: 1 } },
  });
}

function main() {
  await Promise.allSettled([updateOne(), updateTwo()]);
}

権限チェック​

一意でないフィールドをフィルタリングして、更新中に権限をチェックできます。

次の例では、ユーザーが投稿タイトルを更新しようとしています。whereステートメントは、authorIdの値をチェックして、ユーザーが投稿の作成者であることを確認します。アプリケーションは、ユーザーが投稿作成者の場合にのみ投稿タイトルを更新します。

await prisma.post.update({
  where: { id: 1, authorId: 1 },
  data: { title: 'Updated post title' },
});

ソフトデリート​

一意でないフィールドをフィルタリングして、ソフトデリートを処理できます。

次の例では、ソフトデリートされている投稿を返したくありません。操作は、isDeletedの値がfalseの場合にのみ投稿を返します。

prisma.Post.findUnique({ where: { id: postId, isDeleted: false } });

UserWhereUniqueInputの考慮事項​

UserWhereUniqueInputでのブール演算子​

UserWhereUniqueInputを使用する場合、ブール演算子AND、OR、NOTの外側に少なくとも1つの一意のフィールドを指定する必要があります。フィルター内の他の任意の一意フィールドまたは一意でないフィールドと組み合わせて、これらのブール演算子を使用できます。

次の例では、id（一意のフィールド）をemailと組み合わせてテストしています。これは有効です。

await prisma.user.update({
  where: { id: 1, OR: [{ email: "bob@prisma.io" }, { email: "alice@prisma.io" }] },
        // ^^^ Valid: the expression specifies a unique field (`id`) outside of any boolean operators
  data: { ... }
})

// SQL equivalent:
// WHERE id = 1 AND (email = "bob@prisma.io" OR email = "alice@prisma.io")

次の例は無効です。ブール演算子の外側に一意のフィールドがないためです

await prisma.user.update({
  where: { OR: [{ email: "bob@prisma.io" }, { email: "alice@prisma.io" }] },
        // ^^^ Invalid: the expressions does not contain a unique field outside of boolean operators
  data: { ... }
})

1対1のリレーション​

バージョン4.5.0以降、1対1のリレーションの次の操作で一意でないフィールドをフィルタリングできます

  • ネストされた更新
  • ネストされたアップサート
  • ネストされた切断
  • ネストされた削除

Prisma Clientは、適切な関連レコードを選択するために一意のフィルターを自動的に使用します。その結果、生成された型であるWhereUniqueInputを使用してwhereステートメントに一意のフィルターを指定する必要はありません。代わりに、whereステートメントにはWhereInput生成型があります。これを使用して、WhereUniqueInputの制限なしにフィルタリングできます。

ネストされた更新の例​
await prisma.user.update({
  where: { id: 1, },
  data: {
    to_one: {
      // Before Prisma version 4.5.0
      update: { field: "updated" }
      // From Prisma version 4.5.0, you can also do the following:
      update: { where: { /*WhereInput*/ }, data: { field: "updated" } } }
    }
  }
})
ネストされたアップサートの例​
await prisma.user.update({
  where: { id: 1, },
  data: {
    to_one: {
      upsert: {
        where: { /* WhereInput */ } // new argument from Prisma 4.5.0
        create: { /* CreateInput */ },
        update: { /* CreateInput */ },
      }
    }
  }
})
ネストされた切断の例​
await prisma.user.update({
  where: { id: 1, },
  data: {
    to_one: {
      // Before Prisma version 4.5.0
      disconnect: true
      // From Prisma version 4.5.0, you can also do the following:
      disconnect: { /* WhereInput */ }
    }
  }
})
ネストされた削除の例​
await prisma.user.update({
  where: { id: 1, },
  data: {
    to_one: {
      // Before Prisma version 4.5.0
      delete: true
      // From Prisma version 4.5.0, you can also do the following:
      delete: { /* WhereInput */ }
    }
  }
})

PrismaPromiseの動作​

すべてのPrisma Clientクエリは、PrismaPromiseのインスタンスを返します。これは「thenable」です。つまり、PrismaPromiseはawaitまたは.then()または.catch()を呼び出した場合にのみ実行されます。この動作は、すぐに実行を開始する通常のJavaScript Promiseとは異なります。

例:

const findPostOperation = prisma.post.findMany({}); // Query not yet executed

findPostOperation.then(); // Prisma Client now executes the query
// or
await findPostOperation; // Prisma Client now executes the query

$transaction APIを使用すると、この動作により、Prisma Clientはすべてのクエリを単一のトランザクションとしてクエリエンジンに渡すことができます。