Class PopulatedPrisma

Properties

$client $connect $disconnect $executeRaw $executeRawUnsafe $extends $queryRaw $queryRawUnsafe $transaction aggregate count create createMany createManyAndReturn delete deleteMany fields findFirst findFirstOrThrow findMany findUnique findUniqueOrThrow groupBy update updateMany upsert

Properties

Static$client

$client: PrismaClient<PrismaClientOptions, never, DefaultArgs> = prismaClient

Static$connect

$connect: () => Promise<void> = ...

Type declaration

    • (): Promise<void>

    • Connect with the database

      Returns Promise<void>

Static$disconnect

$disconnect: () => Promise<void> = ...

Type declaration

    • (): Promise<void>

    • Disconnect from the database

      Returns Promise<void>

Static$executeRaw

$executeRaw: <T = unknown>(
    query: TemplateStringsArray | Sql,
    ...values: any[],
) => PrismaPromise<number> = ...

Type declaration

    • <T = unknown>(
          query: TemplateStringsArray | Sql,
          ...values: any[],
      ): PrismaPromise<number>

    • Executes a prepared raw query and returns the number of affected rows.

      Type Parameters

      • T = unknown

      Parameters

      • query: TemplateStringsArray | Sql
      • ...values: any[]

      Returns PrismaPromise<number>

      Example

      const result = await prisma.$executeRaw`UPDATE User SET cool = ${true} WHERE email = ${'[email protected]'};`

      Read more in our docs.

Static$executeRawUnsafe

$executeRawUnsafe: <T = unknown>(
    query: string,
    ...values: any[],
) => PrismaPromise<number> = ...

Type declaration

    • <T = unknown>(query: string, ...values: any[]): PrismaPromise<number>

    • Executes a raw query and returns the number of affected rows. Susceptible to SQL injections, see documentation.

      Type Parameters

      • T = unknown

      Parameters

      • query: string
      • ...values: any[]

      Returns PrismaPromise<number>

      Example

      const result = await prisma.$executeRawUnsafe('UPDATE User SET cool = $1 WHERE email = $2 ;', true, '[email protected]')

      Read more in our docs.

Static$extends

$extends: ExtendsHook<
    "extends",
    TypeMapCb<PrismaClientOptions>,
    DefaultArgs,
    TypeMap<InternalArgs & DefaultArgs, {}>,
> = ...

Static$queryRaw

$queryRaw: <T = unknown>(
    query: TemplateStringsArray | Sql,
    ...values: any[],
) => PrismaPromise<T> = ...

Type declaration

    • <T = unknown>(
          query: TemplateStringsArray | Sql,
          ...values: any[],
      ): PrismaPromise<T>

    • Performs a prepared raw query and returns the SELECT data.

      Type Parameters

      • T = unknown

      Parameters

      • query: TemplateStringsArray | Sql
      • ...values: any[]

      Returns PrismaPromise<T>

      Example

      const result = await prisma.$queryRaw`SELECT * FROM User WHERE id = ${1} OR email = ${'[email protected]'};`

      Read more in our docs.

Static$queryRawUnsafe

$queryRawUnsafe: <T = unknown>(
    query: string,
    ...values: any[],
) => PrismaPromise<T> = ...

Type declaration

    • <T = unknown>(query: string, ...values: any[]): PrismaPromise<T>

    • Performs a raw query and returns the SELECT data. Susceptible to SQL injections, see documentation.

      Type Parameters

      • T = unknown

      Parameters

      • query: string
      • ...values: any[]

      Returns PrismaPromise<T>

      Example

      const result = await prisma.$queryRawUnsafe('SELECT * FROM User WHERE id = $1 OR email = $2;', 1, '[email protected]')

      Read more in our docs.

Static$transaction

$transaction: {
    <P extends PrismaPromise<any>[]>(
        arg: [...P[]],
        options?: {},
    ): Promise<UnwrapTuple<P>>;
    <R>(
        fn: (
            prisma: Omit<
                PrismaClient<PrismaClientOptions, never, DefaultArgs>,

                    | "$connect"
                    | "$disconnect"
                    | "$extends"
                    | "$transaction"
                    | "$on"
                    | "$use",
            >,
        ) => Promise<R>,
        options?: {},
    ): Promise<R>;
} = ...

Type declaration

    • <P extends PrismaPromise<any>[]>(
          arg: [...P[]],
          options?: {},
      ): Promise<UnwrapTuple<P>>

    • Allows the running of a sequence of read/write operations that are guaranteed to either succeed or fail as a whole.

      Type Parameters

      • P extends PrismaPromise<any>[]

      Parameters

      • arg: [...P[]]
      • Optionaloptions: {}

      Returns Promise<UnwrapTuple<P>>

      Example

      const [george, bob, alice] = await prisma.$transaction([
        prisma.user.create({ data: { name: 'George' } }),
        prisma.user.create({ data: { name: 'Bob' } }),
        prisma.user.create({ data: { name: 'Alice' } }),
      ])

      Read more in our docs.

    • <R>(
          fn: (
              prisma: Omit<
                  PrismaClient<PrismaClientOptions, never, DefaultArgs>,
                  "$connect" | "$disconnect" | "$extends" | "$transaction" | "$on" | "$use",
              >,
          ) => Promise<R>,
          options?: {},
      ): Promise<R>

    • Allows the running of a sequence of read/write operations that are guaranteed to either succeed or fail as a whole.

      Type Parameters

      • R

      Parameters

      • fn: (
            prisma: Omit<
                PrismaClient<PrismaClientOptions, never, DefaultArgs>,
                "$connect" | "$disconnect" | "$extends" | "$transaction" | "$on" | "$use",
            >,
        ) => Promise<R>
      • Optionaloptions: {}

      Returns Promise<R>

      Example

      const [george, bob, alice] = await prisma.$transaction([
        prisma.user.create({ data: { name: 'George' } }),
        prisma.user.create({ data: { name: 'Bob' } }),
        prisma.user.create({ data: { name: 'Alice' } }),
      ])

      Read more in our docs.

Staticaggregate

aggregate: <T extends Model>(
    model: T,
    query?: ModelAggregateArgs[T],
) => Promise<ThenArg<ModelAggregateResult[T]>> = aggregatePopulatedModel

Staticcount

count: <T extends Model>(
    model: T,
    query?: Omit<ModelCountArgs[T], "select" | "include">,
) => Promise<number> = countPopulatedModel

Staticcreate

create: <T extends Model>(
    model: T,
    data: ModelCreateArgs[T]["data"],
) => Promise<ThenArg<ModelGetPayload[T]>> = createPopulatedModel

StaticcreateMany

createMany: <T extends Model>(
    model: T,
    query: ModelCreateManyArgs[T],
) => Promise<GetBatchResult> = createManyPopulatedModel

StaticcreateManyAndReturn

createManyAndReturn: <T extends Model>(
    model: T,
    query?: Omit<ModelCreateManyAndReturnArgs[T], "select" | "include">,
) => Promise<ThenArg<ModelGetPayload[T]>[]> = createManyPopulatedModelAndReturn

Staticdelete

delete: <T extends Model>(
    model: T,
    where: ModelDeleteArgs[T]["where"],
) => Promise<ThenArg<ModelGetPayload[T]>> = deletePopulatedModel

StaticdeleteMany

deleteMany: <T extends Model>(
    model: T,
    where?: ModelDeleteManyArgs[T]["where"],
) => Promise<GetBatchResult> = deleteManyPopulatedModel

Staticfields

fields: <T extends Model>(model: T) => ModelFieldRefs[T] = fieldsPopulatedModel

StaticfindFirst

findFirst: <T extends Model>(
    model: T,
    query?: Omit<ModelFindFirstArgs[T], "select" | "include">,
) => Promise<null | ThenArg<ModelGetPayload[T]>> = findFirstPopulatedModel

StaticfindFirstOrThrow

findFirstOrThrow: <T extends Model>(
    model: T,
    query?: Omit<ModelFindFirstArgs[T], "select" | "include">,
) => Promise<ThenArg<ModelGetPayload[T]>> = findFirstPopulatedModelOrThrow

StaticfindMany

findMany: <T extends Model>(
    model: T,
    query?: Omit<ModelFindManyArgs[T], "select" | "include">,
) => Promise<ThenArg<ModelGetPayload[T]>[]> = findManyPopulatedModel

StaticfindUnique

findUnique: <T extends Model>(
    model: T,
    where: ModelFindUniqueArgs[T]["where"],
) => Promise<null | ThenArg<ModelGetPayload[T]>> = findUniquePopulatedModel

StaticfindUniqueOrThrow

findUniqueOrThrow: <T extends Model>(
    model: T,
    where: ModelFindUniqueArgs[T]["where"],
) => Promise<ThenArg<ModelGetPayload[T]>> = findUniquePopulatedModelOrThrow

StaticgroupBy

groupBy: <T extends Model>(
    model: T,
    query: ModelGroupByArgs[T],
) => Promise<ThenArg<ModelGroupByPayload[T]>> = groupByPopulatedModel

Staticupdate

update: <T extends Model>(
    model: T,
    query: Omit<ModelUpdateArgs[T], "select" | "include">,
) => Promise<ThenArg<ModelGetPayload[T]>> = updatePopulatedModel

StaticupdateMany

updateMany: <T extends Model>(
    model: T,
    query: ModelUpdateManyArgs[T],
) => Promise<GetBatchResult> = updateManyPopulatedModel

Staticupsert

upsert: <T extends Model>(
    model: T,
    query: Omit<ModelUpsertArgs[T], "select" | "include">,
) => Promise<ThenArg<ModelGetPayload[T]>> = upsertPopulatedModel

Settings

Member Visibility

On This Page

Properties