Class KyselyQueryDriver<DreamInstance>

The order statements that the declared order of the associations the Query is built on or joins contributes to its ORDER BY, in the order they sort, each column namespaced by the alias it is read from. They are read off the same join code that emits them, by building the select.

Retrieves the average value of the specified column for this Query

await Game.query().avg('score')
// 1
Copy

Retrieves the average of the specified column within each group, keyed by the value of the provided group column.

await CompositionAsset.query().avgBy('name', 'score')
// Map(2) { 'primary' => 5, 'secondary' => 4 }
Copy

Retrieves the number of records in the database

await User.query().count()
Copy

Retrieves the number of records in each group, keyed by the value of the provided group column.

await User.query().countBy('name')
// Map(2) { 'fred' => 2, 'zed' => 1 }
Copy

This method is used internally by a Query driver to take the result of a single row in a database, and turn that row into the provided dream instance.

If needed, the return type can be overriden to explicitly define the resulting dream instance, in cases where a proper type for the dream class cannot be inferred, i.e.

this.dbResultToDreamInstance<typeof Dream, DreamInstance>(result, this.dreamClass)
Copy

executes provided query instance as a deletion query.

Used to hydrate dreams with the provided associations

Used by loadBuider

The primary key of each table the Query reaches through a HasOne or HasMany association (one it joins, one an association it joins goes through, or one its association query is built on), namespaced by the alias it is read from, in join order. They are read off the same join code that emits the joins, by building the select.

Retrieves the max value of the specified column for this Query

await User.query().max('id')
// 99
Copy

Retrieves the max value of the specified column within each group, keyed by the value of the provided group column.

await CompositionAsset.query().maxBy('name', 'score')
// Map(2) { 'primary' => 9, 'secondary' => 4 }
Copy

Retrieves the min value of the specified column for this Query

await User.query().min('id')
// 1
Copy

Retrieves the min value of the specified column within each group, keyed by the value of the provided group column.

await CompositionAsset.query().minBy('name', 'score')
// Map(2) { 'primary' => 1, 'secondary' => 4 }
Copy

Returns a new Kysely SelectQueryBuilder instance to be used in a sub Query

const records = await User.where({
  id: Post.query().nestedSelect('userId'),
}).all()
// [User{id: 1}, ...]
Copy

Runs the query and extracts plucked values

A page of a select that carries DISTINCT ON (as a Query that calls distinct, or an association that declares distinct, produces), or null for any other select.

Such a select keeps the row of each group that sorts first in its ORDER BY, so narrowing it to the rows after a cursor would let it keep a row it does not return (a group's later row, once the cursor has passed the group's first). It is read as a derived table instead, and narrowed to rowsAfter, sorted and limited outside it. The Query's order statements follow the select's own ORDER BY, if it has one, so that the select keeps the same row of each group every time it runs, and each of their columns is read out of it under a short alias (as pluck reads them), since a joined table's column cannot be named outside it.

For a select that carries DISTINCT ON (as a Query that calls distinct, or an association that declares distinct, produces), the values of rowKeyColumns for every row it returns, sorted by those columns, ascending; null for any other select.

The select runs as all() runs it, with its own ORDER BY choosing each group's row, and is read as a derived table, sorted outside it. Each of rowKeyColumns is read out of it under a short alias (as pluck reads them), since a joined table's column cannot be named outside it.

Returns the sql that would be executed by this Query

User.where({ email: 'how@yadoin' }).sql()
// {
//  query: {
//    kind: 'SelectQueryNode',
//    from: { kind: 'FromNode', froms: [Array] },
//    selections: [ [Object] ],
//    distinctOn: undefined,
//    joins: undefined,
//    groupBy: undefined,
//    orderBy: undefined,
//    where: { kind: 'WhereNode', where: [Object] },
//    frontModifiers: undefined,
//    endModifiers: undefined,
//    limit: undefined,
//    offset: undefined,
//    with: undefined,
//    having: undefined,
//    explain: undefined,
//    setOperations: undefined
//  },
//  sql: 'select "users".* from "users" where ("users"."email" = $1 and "users"."deleted_at" is null)',
//  parameters: [ 'how@yadoin' ]
//}
Copy

Retrieves the sum value of the specified column for this Query

await Game.query().sum('score')
// 1
Copy

Retrieves the sum of the specified column within each group, keyed by the value of the provided group column.

await CompositionAsset.query().sumBy('name', 'score')
// Map(2) { 'primary' => 10, 'secondary' => 4 }
Copy

Retrieves an array containing all records matching the Query. Be careful using this, since it will attempt to pull every record into memory at once. When querying might return a large number of records, consider using .findEach, which will pull the records in batches.

await User.query().all()
Copy

Used for applying first and last queries

Converts the given dream class into a Kysely query, enabling you to build custom queries using the Kysely API

await User.query().toKysely('select').where('email', '=', 'how@yadoin').execute()
Copy

executes provided query instance as an update query.

destroys a dream, possibly implementing soft delete if reallyDestroy is false and the record being deleted implements soft delete. Does nothing at all when a beforeDestroy hook called preventDeletion.

returns the foreign key type based on the primary key received. gives the driver the opportunity to switch i.e. bigserial to bigint.

This should build a new migration file in the migrations folder of your application. This will then need to be read and run whenever the migrate method is called. The filename should contain a timestamp at the front of the filename, so that it is sorted by date in the file tree, and, more importantly, so they can be run in order by your migration runner.

migrate the database. Must respond to the NODE_ENV value.

used to return the computed primary key type based on the primaryKeyType set in the DreamApp class.

rollback the database. Must respond to the NODE_ENV value.

persists any unsaved changes to the database. If a transaction is provided as a second argument, it will use that transaction to encapsulate the persisting of the dream, as well as any subsequent model hooks that are fired.

RETURNING * (rather than enumerating the compiled column list) keeps writes working under schema/image skew: during a rolling deploy, a container built before a drop-column migration would otherwise name the dropped column in RETURNING and fail with 42703 column does not exist on every write, even writes that never touch that column. The SET/VALUES half still names only dirty attributes, so a write that actually sets a dropped column still fails loudly. The returned row is filtered to the compiled column list before hydration (see internal/saveDream.ts), so a column the image doesn't know about never reaches setAttributes.

KNOWN CONSTRAINT: star-selects are only safe because nothing in this stack uses named prepared statements — node-postgres prepares a statement only when given an explicit name, and Kysely never names them, so every query is re-planned. With named prepared statements, a concurrent ADD COLUMN changes a cached plan's result shape and Postgres raises cached plan must not change result type (the reason Rails added enumerate_columns_in_select_statements). If a future driver or pooling layer enables named prepared statements, revisit every RETURNING * / select * in this driver.

defines the syncing behavior for dream and psychic, which is run whenever the sync command is called.

Builds a new DreamTransaction instance, provides the instance to the provided callback.

await ApplicationModel.transaction(async txn => {
  const user = await User.txn(txn).create({ email: 'how@yadoin' })
  await Pet.txn(txn).create({ user })
})
Copy