Class Setof<Q>

constructor

• new Setof<Q extends Query>(
      rawFromExpr: Expression,
      fromAlias: QueryAlias,
      joinAliases: { [key: string]: QueryAlias },
      query: Q,
      fromRow: RowLike | Scalar,
  ): Setof<Q>

  Type Parameters

  • Q extends Query

  Parameters

  • rawFromExpr: Expression
  • fromAlias: QueryAlias
  • joinAliases: { [key: string]: QueryAlias }
  • query: Q
  • fromRow: RowLike | Scalar

  Returns Setof<Q>

fromAlias

fromRow

joinAliases

query

rawFromExpr

compile

• compile(ctxIn: Context): RawBuilder<unknown>

  Parameters

  • ctxIn: Context

  Returns RawBuilder<unknown>

debug

• debug(): Setof<Q>

  Returns Setof<Q>

execute

• execute(db: Kysely<any>): Promise<AwaitedResultType<Q>>

  Parameters

  • db: Kysely<any>

  Returns Promise<AwaitedResultType<Q>>

groupBy

• groupBy<G extends Any<unknown, 0 | 1>[]>(
      fn: (from: Q["from"]) => G,
  ): Setof<
      Q & {
          groupBy: [
              ...(Q["groupBy"] extends unknown[] ? any[any] : [])[],
              ...G[],
          ];
      },
  >

  Type Parameters

  • G extends Any<unknown, 0 | 1>[]

  Parameters

  • fn: (from: Q["from"]) => G

  Returns Setof<
      Q & {
          groupBy: [
              ...(Q["groupBy"] extends unknown[] ? any[any] : [])[],
              ...G[],
          ];
      },
  >

join

• join<J extends Query, A extends string>(
      j: Setof<J>,
      as: A,
      on: (
          from: Q["from"],
          js: JoinTables<Q> & { [a in string]: ResultType<J> },
      ) => boolean | Bool<0 | 1>,
  ): Setof<
      Q & {
          joins: Q["joins"] & {
              [a in string]: { on: Bool<0 | 1>; row: RowLike; table: Setof<J> }
          };
      },
  >

  Type Parameters

  • J extends Query
  • A extends string

  Parameters

  • j: Setof<J>
  • as: A
  • on: (
        from: Q["from"],
        js: JoinTables<Q> & { [a in string]: ResultType<J> },
    ) => boolean | Bool<0 | 1>

  Returns Setof<
      Q & {
          joins: Q["joins"] & {
              [a in string]: { on: Bool<0 | 1>; row: RowLike; table: Setof<J> }
          };
      },
  >

joinTables

• joinTables(): JoinTables<Q>

  Returns JoinTables<Q>

scalar

• scalar<S extends Scalar>(this: Setof<{ from: RowLike | Scalar; select: S }>): S

  Type Parameters

  • S extends Scalar

  Parameters

  • this: Setof<{ from: RowLike | Scalar; select: S }>

  Returns S

select

• select<S extends RowLikeRelaxed | ScalarRelaxed>(
      fn: (...from: SelectArgs<Q>) => S,
  ): Setof<Q & { select: MaybePrimitiveToSqlType<S> }>

  Type Parameters

  • S extends RowLikeRelaxed | ScalarRelaxed

  Parameters

  • fn: (...from: SelectArgs<Q>) => S

  Returns Setof<Q & { select: MaybePrimitiveToSqlType<S> }>

subquery

• subquery(): Setof<{ from: ResultType<Q> }>

  Returns Setof<{ from: ResultType<Q> }>

tableColumnAlias

• tableColumnAlias(): RawBuilder<unknown>

  Returns RawBuilder<unknown>

toSelectArgs

• toSelectArgs(): SelectArgs<Q>

  Returns SelectArgs<Q>

where

• where(
      fn: (...from: SelectArgs<Q>) => boolean | Bool<0 | 1>,
  ): Setof<
      Q & {
          wheres: | [Bool<0 | 1>, ...Bool<0 | 1>[], Bool<0 | 1> | Bool<1>]
          | [Bool<0 | 1> | Bool<1>];
      },
  >

  Parameters

  • fn: (...from: SelectArgs<Q>) => boolean | Bool<0 | 1>

  Returns Setof<
      Q & {
          wheres: | [Bool<0 | 1>, ...Bool<0 | 1>[], Bool<0 | 1> | Bool<1>]
          | [Bool<0 | 1> | Bool<1>];
      },
  >

Staticof

• of<R extends RowLike>(fromRow: R): typeof __class

  Type Parameters

  • R extends RowLike

  Parameters

  • fromRow: R

  Returns typeof __class

StaticofSchema

• ofSchema(fromRow: { [key: string]: typeof Any }): typeof __class

  Parameters

  • fromRow: { [key: string]: typeof Any }

  Returns typeof __class