Interim

src/core/Builder.ts

@@ -1,5 +1,5 @@
-import {getData, internalData, type HasTable} from './Internal.ts'
-import type {QueryMeta} from './MetaData.ts'
+import {getData, internalData, type HasSql, type HasTable} from './Internal.ts'
+import type {IsPostgres, QueryMeta} from './MetaData.ts'
 import type {QueryData} from './Query.ts'
 import type {SelectionInput} from './Selection.ts'
 import type {Table, TableDefinition} from './Table.ts'
@@ -59,6 +59,28 @@ export class Builder<Meta extends QueryMeta> {
     })
   }
 
+  selectDistinctOn(
+    this: Builder<IsPostgres>,
+    columns: Array<HasSql>
+  ): WithoutSelection<Meta>
+  selectDistinctOn<Input extends SelectionInput>(
+    this: Builder<IsPostgres>,
+    columns: Array<HasSql>,
+    selection: Input
+  ): WithSelection<Input, Meta>
+  selectDistinctOn(columns: any, selection?: any): any {
+    return new Select({
+      ...getData(this),
+      select: {
+        type: selection ? 'selection' : 'allFrom',
+        input: selection,
+        tables: [],
+        nullable: []
+      },
+      distinctOn: columns
+    })
+  }
+
   update<Definition extends TableDefinition>(table: Table<Definition>) {
     return new UpdateTable<Definition, Meta>({...getData(this), table})
   }

src/core/Emitter.ts

@@ -108,12 +108,24 @@ export abstract class Emitter {
   }
 
   emitSelect(select: Select<unknown>): void {
-    const {from, distinct, where, groupBy, orderBy, having, limit, offset} =
-      getData(select)
+    const {
+      from,
+      distinct,
+      distinctOn,
+      where,
+      groupBy,
+      orderBy,
+      having,
+      limit,
+      offset
+    } = getData(select)
     const selected = getSelection(select)
+    const prefix = distinctOn
+      ? sql`distinct on (${sql.join(distinctOn, sql`, `)})`
+      : distinct && sql`distinct`
     sql
       .query({
-        select: distinct ? sql`distinct ${selected}` : selected,
+        select: sql.join([prefix, selected]),
         from,
         where,
         groupBy,

src/core/MetaData.ts

@@ -22,6 +22,14 @@ export interface IsPostgres extends QueryMeta {
   dialect: 'postgres'
 }
 
+export interface IsMysql extends QueryMeta {
+  dialect: 'mysql'
+}
+
+export interface IsSqlite extends QueryMeta {
+  dialect: 'sqlite'
+}
+
 export interface Either extends QueryMeta {
   mode: 'sync' | 'async'
   dialect: QueryDialect

src/core/query/Insert.ts

@@ -11,7 +11,12 @@ import {
 } from '../Internal.ts'
 import type {IsPostgres, QueryMeta} from '../MetaData.ts'
 import {Query, QueryData} from '../Query.ts'
-import {selection, type Selection} from '../Selection.ts'
+import {
+  selection,
+  type Selection,
+  type SelectionInput,
+  type SelectionRow
+} from '../Selection.ts'
 import {sql} from '../Sql.ts'
 import type {
   TableDefinition,
@@ -53,8 +58,10 @@ class InsertCanReturn<
   Meta extends QueryMeta
 > extends Insert<void, Meta> {
   returning(): Insert<TableRow<Definition>, Meta>
-  returning<T>(returning: HasSql<T>): Insert<T, Meta>
-  returning(returning?: HasSql) {
+  returning<Input extends SelectionInput>(
+    returning: Input
+  ): Insert<SelectionRow<Input>, Meta>
+  returning(returning?: SelectionInput) {
     const data = getData(this)
     return new Insert({
       ...data,

src/core/query/Select.ts

@@ -15,7 +15,7 @@ import {
   type HasSql,
   type HasTable
 } from '../Internal.ts'
-import type {QueryMeta} from '../MetaData.ts'
+import type {IsMysql, IsPostgres, QueryMeta} from '../MetaData.ts'
 import {Query, QueryData} from '../Query.ts'
 import {
   selection,
@@ -41,6 +41,7 @@ export class SelectData<Meta extends QueryMeta> extends QueryData<Meta> {
     input?: SelectionInput
   }
   distinct?: boolean
+  distinctOn?: Array<HasSql>
   from?: HasSql
   subject?: HasSql
   where?: HasSql
@@ -205,6 +206,19 @@ export class Select<Input, Meta extends QueryMeta = QueryMeta>
     })
   }
 
+  intersectAll(
+    this: SelectBase<Input, IsPostgres | IsMysql>,
+    right: SelectBase<Input, Meta>
+  ): Union<Input, Meta> {
+    return new Union({
+      ...getData(<SelectBase<Input, Meta>>this),
+      selection: getSelection(this),
+      left: this,
+      operator: sql`intersect all`,
+      right
+    })
+  }
+
   except(right: SelectBase<Input, Meta>): Union<Input, Meta> {
     return new Union({
       ...getData(this),
@@ -215,6 +229,18 @@ export class Select<Input, Meta extends QueryMeta = QueryMeta>
     })
   }
 
+  exceptAll(
+    right: SelectBase<Input, IsPostgres | IsMysql>
+  ): Union<Input, Meta> {
+    return new Union({
+      ...getData(<SelectBase<Input, Meta>>this),
+      selection: getSelection(this),
+      left: this,
+      operator: sql`except all`,
+      right
+    })
+  }
+
   get [internalSelection]() {
     const {select} = getData(this)
     if (!select.input) throw new Error('No selection defined')
@@ -240,7 +266,12 @@ export interface SelectBase<Input, Meta extends QueryMeta>
   union(right: SelectBase<Input, Meta>): Union<Input, Meta>
   unionAll(right: SelectBase<Input, Meta>): Union<Input, Meta>
   intersect(right: SelectBase<Input, Meta>): Union<Input, Meta>
+  intersectAll(
+    this: SelectBase<Input, IsPostgres | IsMysql>,
+    right: SelectBase<Input, Meta>
+  ): Union<Input, Meta>
   except(right: SelectBase<Input, Meta>): Union<Input, Meta>
+  exceptAll(right: SelectBase<Input, IsPostgres | IsMysql>): Union<Input, Meta>
   as(name: string): SubQuery<Input>
 }
 

src/core/query/Union.ts

@@ -7,7 +7,7 @@ import {
   type HasSelection,
   type HasSql
 } from '../Internal.ts'
-import type {QueryMeta} from '../MetaData.ts'
+import type {IsMysql, IsPostgres, QueryMeta} from '../MetaData.ts'
 import {Query, QueryData} from '../Query.ts'
 import type {Selection} from '../Selection.ts'
 import {sql} from '../Sql.ts'
@@ -73,3 +73,45 @@ export class Union<Result, Meta extends QueryMeta = QueryMeta>
     return sql.chunk('emitUnion', this)
   }
 }
+
+export function union<Result, Meta extends QueryMeta>(
+  left: SelectBase<Result, Meta>,
+  right: SelectBase<Result, Meta>
+): Union<Result, Meta> {
+  return left.union(right)
+}
+
+export function unionAll<Result, Meta extends QueryMeta>(
+  left: SelectBase<Result, Meta>,
+  right: SelectBase<Result, Meta>
+): Union<Result, Meta> {
+  return left.unionAll(right)
+}
+
+export function intersect<Result, Meta extends QueryMeta>(
+  left: SelectBase<Result, Meta>,
+  right: SelectBase<Result, Meta>
+): Union<Result, Meta> {
+  return left.intersect(right)
+}
+
+export function intersectAll<Result, Meta extends IsPostgres | IsMysql>(
+  left: SelectBase<Result, Meta>,
+  right: SelectBase<Result, Meta>
+): Union<Result, Meta> {
+  return left.intersectAll(right)
+}
+
+export function except<Result, Meta extends QueryMeta>(
+  left: SelectBase<Result, Meta>,
+  right: SelectBase<Result, Meta>
+): Union<Result, Meta> {
+  return left.except(right)
+}
+
+export function exceptAll<Result, Meta extends IsPostgres | IsMysql>(
+  left: SelectBase<Result, Meta>,
+  right: SelectBase<Result, Meta>
+): Union<Result, Meta> {
+  return left.exceptAll(right)
+}

src/core/query/Update.ts

@@ -49,7 +49,7 @@ export class UpdateTable<
   Definition extends TableDefinition,
   Meta extends QueryMeta
 > extends Update<void, Meta> {
-  set(values: TableUpdate<Definition>) {
+  set(values: TableUpdate<Definition>): UpdateTable<Definition, Meta> {
     const set = sql.join(
       Object.entries(values).map(
         ([key, value]) => sql`${sql.identifier(key)} = ${input(value)}`
@@ -59,11 +59,13 @@ export class UpdateTable<
     return new UpdateTable<Definition, Meta>({...getData(this), set})
   }
 
-  where(where: HasSql<boolean>) {
+  where(where: HasSql<boolean>): UpdateTable<Definition, Meta> {
     return new UpdateTable<Definition, Meta>({...getData(this), where})
   }
 
-  returning<Input extends SelectionInput>(returning: Input) {
+  returning<Input extends SelectionInput>(
+    returning: Input
+  ): Update<SelectionRow<Input>, Meta> {
     return new Update<SelectionRow<Input>, Meta>({
       ...getData(this),
       returning: selection(returning)

test/driver/pglite.test.ts

@@ -1,7 +1,9 @@
+import {Os} from '@sinclair/carbon'
 import {connect} from '../../src/driver/pglite.ts'
 import {testDriver} from '../TestDriver.ts'
 
-await testDriver('pglite', async () => {
-  const {PGlite} = await import('@electric-sql/pglite')
-  return connect(new PGlite())
-})
+if (Os.type() !== 'win32')
+  await testDriver('pglite', async () => {
+    const {PGlite} = await import('@electric-sql/pglite')
+    return connect(new PGlite())
+  })