From d59e4867299d10be68dc104db6879e96ff04f577 Mon Sep 17 00:00:00 2001
From: Javier <javier.garcia@meteologica.com>
Date: Tue, 10 Aug 2021 18:40:39 +0200
Subject: [PATCH] Modular types

---
 db.mjs                        |   8 +
 src/db/conditions.ts          |  76 ++--
 src/db/core.ts                |  83 +++-
 src/db/shortcuts.ts           | 755 ++++++++++++++++++++++------------
 src/generate/config.ts        |   8 +-
 src/generate/tables.ts        |  77 ++--
 src/generate/tsOutput.ts      |   6 +-
 src/typings/zapatos/schema.ts |  22 -
 tsconfig.json                 |   9 +-
 9 files changed, 656 insertions(+), 388 deletions(-)
 delete mode 100644 src/typings/zapatos/schema.ts

diff --git a/db.mjs b/db.mjs
index 2c7fb6c..fd9c93b 100644
--- a/db.mjs
+++ b/db.mjs
@@ -20,6 +20,12 @@ export const constraint = mod.constraint;
 export const count = mod.count;
 export const deletes = mod.deletes;
 export const doNothing = mod.doNothing;
+export const genericAvg = mod.genericAvg;
+export const genericCount = mod.genericCount;
+export const genericMax = mod.genericMax;
+export const genericMin = mod.genericMin;
+export const genericSelectExactlyOne = mod.genericSelectExactlyOne;
+export const genericSum = mod.genericSum;
 export const getConfig = mod.getConfig;
 export const insert = mod.insert;
 export const isDatabaseError = mod.isDatabaseError;
@@ -43,6 +49,8 @@ export const setConfig = mod.setConfig;
 export const sql = mod.sql;
 export const strict = mod.strict;
 export const sum = mod.sum;
+export const table = mod.table;
+export const tables = mod.tables;
 export const toBuffer = mod.toBuffer;
 export const toDate = mod.toDate;
 export const toString = mod.toString;
diff --git a/src/db/conditions.ts b/src/db/conditions.ts
index 6d0a8df..f66843e 100644
--- a/src/db/conditions.ts
+++ b/src/db/conditions.ts
@@ -10,7 +10,7 @@ import {
   Parameter,
   param,
   sql,
-  SQL,
+  GenericSQL,
   self,
   vals,
 } from './core';
@@ -20,47 +20,47 @@ import { mapWithSeparator } from './utils';
 
 const conditionalParam = (a: any) => a instanceof SQLFragment || a instanceof ParentColumn || a instanceof Parameter ? a : param(a);
 
-export const isNull = sql<SQL, boolean>`${self} IS NULL`;
-export const isNotNull = sql<SQL, boolean>`${self} IS NOT NULL`;
-export const isTrue = sql<SQL, boolean>`${self} IS TRUE`;
-export const isNotTrue = sql<SQL, boolean>`${self} IS NOT TRUE`;
-export const isFalse = sql<SQL, boolean>`${self} IS FALSE`;
-export const isNotFalse = sql<SQL, boolean>`${self} IS NOT FALSE`;
-export const isUnknown = sql<SQL, boolean>`${self} IS UNKNOWN`;
-export const isNotUnknown = sql<SQL, boolean>`${self} IS NOT UNKNOWN`;
+export const isNull = sql<GenericSQL, boolean>`${self} IS NULL`;
+export const isNotNull = sql<GenericSQL, boolean>`${self} IS NOT NULL`;
+export const isTrue = sql<GenericSQL, boolean>`${self} IS TRUE`;
+export const isNotTrue = sql<GenericSQL, boolean>`${self} IS NOT TRUE`;
+export const isFalse = sql<GenericSQL, boolean>`${self} IS FALSE`;
+export const isNotFalse = sql<GenericSQL, boolean>`${self} IS NOT FALSE`;
+export const isUnknown = sql<GenericSQL, boolean>`${self} IS UNKNOWN`;
+export const isNotUnknown = sql<GenericSQL, boolean>`${self} IS NOT UNKNOWN`;
 
-export const isDistinctFrom = <T>(a: T) => sql<SQL, boolean, T>`${self} IS DISTINCT FROM ${conditionalParam(a)}`;
-export const isNotDistinctFrom = <T>(a: T) => sql<SQL, boolean, T>`${self} IS NOT DISTINCT FROM ${conditionalParam(a)}`;
+export const isDistinctFrom = <T>(a: T) => sql<GenericSQL, boolean, T>`${self} IS DISTINCT FROM ${conditionalParam(a)}`;
+export const isNotDistinctFrom = <T>(a: T) => sql<GenericSQL, boolean, T>`${self} IS NOT DISTINCT FROM ${conditionalParam(a)}`;
 
-export const eq = <T>(a: T) => sql<SQL, boolean | null, T>`${self} = ${conditionalParam(a)}`;
-export const ne = <T>(a: T) => sql<SQL, boolean | null, T>`${self} <> ${conditionalParam(a)}`;
-export const gt = <T>(a: T) => sql<SQL, boolean | null, T>`${self} > ${conditionalParam(a)}`;
-export const gte = <T>(a: T) => sql<SQL, boolean | null, T>`${self} >= ${conditionalParam(a)}`;
-export const lt = <T>(a: T) => sql<SQL, boolean | null, T>`${self} < ${conditionalParam(a)}`;
-export const lte = <T>(a: T) => sql<SQL, boolean | null, T>`${self} <= ${conditionalParam(a)}`;
+export const eq = <T>(a: T) => sql<GenericSQL, boolean | null, T>`${self} = ${conditionalParam(a)}`;
+export const ne = <T>(a: T) => sql<GenericSQL, boolean | null, T>`${self} <> ${conditionalParam(a)}`;
+export const gt = <T>(a: T) => sql<GenericSQL, boolean | null, T>`${self} > ${conditionalParam(a)}`;
+export const gte = <T>(a: T) => sql<GenericSQL, boolean | null, T>`${self} >= ${conditionalParam(a)}`;
+export const lt = <T>(a: T) => sql<GenericSQL, boolean | null, T>`${self} < ${conditionalParam(a)}`;
+export const lte = <T>(a: T) => sql<GenericSQL, boolean | null, T>`${self} <= ${conditionalParam(a)}`;
 
-export const between = <T>(a: T, b: T) => sql<SQL, boolean | null, T> `${self} BETWEEN (${conditionalParam(a)}) AND (${conditionalParam(b)})`;
-export const betweenSymmetric = <T>(a: T, b: T) => sql<SQL, boolean | null, T> `${self} BETWEEN SYMMETRIC (${conditionalParam(a)}) AND (${conditionalParam(b)})`;
-export const notBetween = <T>(a: T, b: T) => sql<SQL, boolean | null, T> `${self} NOT BETWEEN (${conditionalParam(a)}) AND (${conditionalParam(b)})`;
-export const notBetweenSymmetric = <T>(a: T, b: T) => sql<SQL, boolean | null, T> `${self} NOT BETWEEN SYMMETRIC (${conditionalParam(a)}) AND (${conditionalParam(b)})`;
+export const between = <T>(a: T, b: T) => sql<GenericSQL, boolean | null, T> `${self} BETWEEN (${conditionalParam(a)}) AND (${conditionalParam(b)})`;
+export const betweenSymmetric = <T>(a: T, b: T) => sql<GenericSQL, boolean | null, T> `${self} BETWEEN SYMMETRIC (${conditionalParam(a)}) AND (${conditionalParam(b)})`;
+export const notBetween = <T>(a: T, b: T) => sql<GenericSQL, boolean | null, T> `${self} NOT BETWEEN (${conditionalParam(a)}) AND (${conditionalParam(b)})`;
+export const notBetweenSymmetric = <T>(a: T, b: T) => sql<GenericSQL, boolean | null, T> `${self} NOT BETWEEN SYMMETRIC (${conditionalParam(a)}) AND (${conditionalParam(b)})`;
 
-export const like = <T extends string>(a: T) => sql<SQL, boolean | null, T>`${self} LIKE ${conditionalParam(a)}`;
-export const notLike = <T extends string>(a: T) => sql<SQL, boolean | null, T>`${self} NOT LIKE ${conditionalParam(a)}`;
-export const ilike = <T extends string>(a: T) => sql<SQL, boolean | null, T>`${self} ILIKE ${conditionalParam(a)}`;
-export const notIlike = <T extends string>(a: T) => sql<SQL, boolean | null, T>`${self} NOT ILIKE ${conditionalParam(a)}`;
-export const similarTo = <T extends string>(a: T) => sql<SQL, boolean | null, T>`${self} SIMILAR TO ${conditionalParam(a)}`;
-export const notSimilarTo = <T extends string>(a: T) => sql<SQL, boolean | null, T>`${self} NOT SIMILAR TO ${conditionalParam(a)}`;
-export const reMatch = <T extends string>(a: T) => sql<SQL, boolean | null, T>`${self} ~ ${conditionalParam(a)}`;
-export const reImatch = <T extends string>(a: T) => sql<SQL, boolean | null, T>`${self} ~* ${conditionalParam(a)}`;
-export const notReMatch = <T extends string>(a: T) => sql<SQL, boolean | null, T>`${self} !~ ${conditionalParam(a)}`;
-export const notReImatch = <T extends string>(a: T) => sql<SQL, boolean | null, T>`${self} !~* ${conditionalParam(a)}`;
+export const like = <T extends string>(a: T) => sql<GenericSQL, boolean | null, T>`${self} LIKE ${conditionalParam(a)}`;
+export const notLike = <T extends string>(a: T) => sql<GenericSQL, boolean | null, T>`${self} NOT LIKE ${conditionalParam(a)}`;
+export const ilike = <T extends string>(a: T) => sql<GenericSQL, boolean | null, T>`${self} ILIKE ${conditionalParam(a)}`;
+export const notIlike = <T extends string>(a: T) => sql<GenericSQL, boolean | null, T>`${self} NOT ILIKE ${conditionalParam(a)}`;
+export const similarTo = <T extends string>(a: T) => sql<GenericSQL, boolean | null, T>`${self} SIMILAR TO ${conditionalParam(a)}`;
+export const notSimilarTo = <T extends string>(a: T) => sql<GenericSQL, boolean | null, T>`${self} NOT SIMILAR TO ${conditionalParam(a)}`;
+export const reMatch = <T extends string>(a: T) => sql<GenericSQL, boolean | null, T>`${self} ~ ${conditionalParam(a)}`;
+export const reImatch = <T extends string>(a: T) => sql<GenericSQL, boolean | null, T>`${self} ~* ${conditionalParam(a)}`;
+export const notReMatch = <T extends string>(a: T) => sql<GenericSQL, boolean | null, T>`${self} !~ ${conditionalParam(a)}`;
+export const notReImatch = <T extends string>(a: T) => sql<GenericSQL, boolean | null, T>`${self} !~* ${conditionalParam(a)}`;
 
-export const isIn = <T>(a: readonly T[]) => a.length > 0 ? sql<SQL, boolean | null, T>`${self} IN (${vals(a)})` : sql`false`;
-export const isNotIn = <T>(a: readonly T[]) => a.length > 0 ? sql<SQL, boolean | null, T>`${self} NOT IN (${vals(a)})` : sql`true`;
+export const isIn = <T>(a: readonly T[]) => a.length > 0 ? sql<GenericSQL, boolean | null, T>`${self} IN (${vals(a)})` : sql`false`;
+export const isNotIn = <T>(a: readonly T[]) => a.length > 0 ? sql<GenericSQL, boolean | null, T>`${self} NOT IN (${vals(a)})` : sql`true`;
 
-export const or = <T>(...conditions: SQLFragment<any, T>[]) => sql<SQL, boolean | null, T>`(${mapWithSeparator(conditions, sql` OR `, c => c)})`;
-export const and = <T>(...conditions: SQLFragment<any, T>[]) => sql<SQL, boolean | null, T>`(${mapWithSeparator(conditions, sql` AND `, c => c)})`;
-export const not = <T>(condition: SQLFragment<any, T>) => sql<SQL, boolean | null, T>`(NOT ${condition})`;
+export const or = <T>(...conditions: SQLFragment<any, T>[]) => sql<GenericSQL, boolean | null, T>`(${mapWithSeparator(conditions, sql` OR `, c => c)})`;
+export const and = <T>(...conditions: SQLFragment<any, T>[]) => sql<GenericSQL, boolean | null, T>`(${mapWithSeparator(conditions, sql` AND `, c => c)})`;
+export const not = <T>(condition: SQLFragment<any, T>) => sql<GenericSQL, boolean | null, T>`(NOT ${condition})`;
 
 // things that aren't genuinely conditions
 type IntervalUnit = 'microsecond' | 'millisecond' | 'second' | 'minute' | 'hour' | 'day' | 'week' | 'month' | 'year' | 'decade' | 'century' | 'millennium';
@@ -69,5 +69,5 @@ export const after = gt;
 export const before = lt;
 
 // these are really more operations than conditions, but we sneak them in here for now, for use e.g. in UPDATE queries
-export const add = <T extends number | Date>(a: T) => sql<SQL, number, T>`${self} + ${conditionalParam(a)}`;
-export const subtract = <T extends number | Date>(a: T) => sql<SQL, number, T>`${self} - ${conditionalParam(a)}`;
+export const add = <T extends number | Date>(a: T) => sql<GenericSQL, number, T>`${self} + ${conditionalParam(a)}`;
+export const subtract = <T extends number | Date>(a: T) => sql<GenericSQL, number, T>`${self} - ${conditionalParam(a)}`;
diff --git a/src/db/core.ts b/src/db/core.ts
index 30b2825..0ea077b 100644
--- a/src/db/core.ts
+++ b/src/db/core.ts
@@ -10,16 +10,17 @@ import { performance } from 'perf_hooks';
 import { getConfig, SQLQuery } from './config';
 import { isPOJO, NoInfer } from './utils';
 
-import type {
-  Updatable,
-  Whereable,
-  Table,
-  Column,
-} from 'zapatos/schema';
-
 
 // === symbols, types, wrapper classes and shortcuts ===
 
+declare global {
+  namespace Zapatos {
+    /** Injects additional structures on Zapatos.StructureMap */
+    interface StructureMap {
+    }
+  }
+}
+
 /**
  * Compiles to `DEFAULT` for use in `INSERT`/`UPDATE` queries.
  */
@@ -73,6 +74,8 @@ export type NumberRangeString = RangeString<number | ''>;
  */
 export type ByteArrayString = `\\x${string}`;
 
+export type Column <S extends GenericSQLStructure> = Exclude<keyof S['Selectable'], number | symbol>;
+
 /**
  * Make a function `STRICT` in the Postgres sense — where it's an alias for
  * `RETURNS NULL ON NULL INPUT` — with appropriate typing.
@@ -189,17 +192,44 @@ export function vals<T>(x: T) { return new ColumnValues<T>(x); }
  * Compiles to the name of the column it wraps in the table of the parent query.
  * @param value The column name
  */
-export class ParentColumn<T extends Column = Column> { constructor(public value: T) { } }
+export class ParentColumn<T extends Column<GenericSQLStructure> = Column<SQLStructure>> { constructor(public value: T) { } }
 /**
  * Returns a `ParentColumn` instance, wrapping a column name, which compiles to
  * that column name of the table of the parent query.
  */
-export function parent<T extends Column = Column>(x: T) { return new ParentColumn<T>(x); }
+export function parent<T extends Column<GenericSQLStructure> = Column<SQLStructure>>(x: T) { return new ParentColumn<T>(x); }
 
 
 export type GenericSQLExpression = SQLFragment<any, any> | Parameter | DefaultType | DangerousRawString | SelfType;
-export type SQLExpression = Table | ColumnNames<Updatable | (keyof Updatable)[]> | ColumnValues<Updatable | any[]> | Whereable | Column | GenericSQLExpression;
-export type SQL = SQLExpression | SQLExpression[];
+
+export interface GenericSQLStructure {
+  Schema: string;
+  Table: string;
+  Selectable: { [k: string]: any };
+  JSONSelectable: object;
+  Whereable: object;
+  Insertable: object;
+  Updatable: object;
+  UniqueIndex: string;
+}
+
+export type SQLExpressionForStructure <S extends GenericSQLStructure> = GenericSQLExpression | ColumnNames<S['Updatable'] | (keyof S['Updatable'])[] | readonly (keyof S['Updatable'])[]> | ColumnValues<S['Updatable']> | S['Table'] | S['Schema'] | S['Whereable'] | Column<S>;
+export type SQLForStructure <S extends GenericSQLStructure> = SQLExpressionForStructure<S> | Array<SQLExpressionForStructure<S>>;
+
+export type GenericSQL = 
+  | GenericSQLExpression
+  | ColumnNames<GenericSQLStructure['Updatable']
+  | (keyof GenericSQLStructure['Updatable'])[]>
+  | ColumnValues<GenericSQLStructure['Updatable']>
+  | GenericSQLStructure['Table']
+  | GenericSQLStructure['Schema']
+  | GenericSQLStructure['Whereable']
+  | Column<GenericSQLStructure>;
+
+// eslint-disable-next-line no-undef
+export type SQLStructure = { [Key in keyof Zapatos.StructureMap]: Zapatos.StructureMap[Key] }[keyof Zapatos.StructureMap];
+
+export type SQL = SQLForStructure<SQLStructure>;
 
 export type Queryable = pg.ClientBase | pg.Pool;
 
@@ -212,14 +242,23 @@ export type Queryable = pg.ClientBase | pg.Pool;
  * defines what type the `SQLFragment` produces, where relevant (i.e. when
  * calling `.run(...)` on it, or using it as the value of an `extras` object).
  */
-export function sql<
-  Interpolations = SQL,
-  RunResult = pg.QueryResult['rows'],
-  Constraint = never,
-  >(literals: TemplateStringsArray, ...expressions: NoInfer<Interpolations>[]) {
-  return new SQLFragment<RunResult, Constraint>(Array.prototype.slice.apply(literals), expressions);
+interface SqlSignatures {
+  <
+    Interpolations = SQL,
+    RunResult = pg.QueryResult['rows'],
+    Constraint = never,
+  >(literals: TemplateStringsArray, ...expressions: NoInfer<Interpolations>[]): SQLFragment<RunResult, Constraint>;
+  <
+    Structure extends GenericSQLStructure = SQLStructure,
+    RunResult = pg.QueryResult['rows'],
+    Constraint = never,
+    >(literals: TemplateStringsArray, ...expressions: NoInfer<SQLForStructure<Structure>>[]): SQLFragment<RunResult, Constraint>;
 }
 
+export const sql: SqlSignatures = (literals: TemplateStringsArray, ...expressions: NoInfer<GenericSQL>[]) => {
+  return new SQLFragment<pg.QueryResult['rows'], never>(Array.prototype.slice.apply(literals), expressions);
+};
+
 let preparedNameSeq = 0;
 
 export class SQLFragment<RunResult = pg.QueryResult['rows'], Constraint = never> {
@@ -239,7 +278,7 @@ export class SQLFragment<RunResult = pg.QueryResult['rows'], Constraint = never>
   noop = false;  // if true, bypass actually running the query unless forced to e.g. for empty INSERTs
   noopResult: any;  // if noop is true and DB is bypassed, what should be returned?
 
-  constructor(protected literals: string[], protected expressions: SQL[]) { }
+  constructor(protected literals: string[], protected expressions: GenericSQL[]) { }
 
   /**
    * Instruct Postgres to treat this as a prepared statement: see
@@ -286,7 +325,7 @@ export class SQLFragment<RunResult = pg.QueryResult['rows'], Constraint = never>
    * that could be passed to the `pg` query function. Arguments are generally
    * only passed when the function calls itself recursively.
    */
-  compile = (result: SQLQuery = { text: '', values: [] }, parentTable?: string, currentColumn?: Column) => {
+  compile = (result: SQLQuery = { text: '', values: [] }, parentTable?: string, currentColumn?: Column<GenericSQLStructure>) => {
     if (this.parentTable) parentTable = this.parentTable;
 
     if (this.noop) result.text += "/* marked no-op: won't hit DB unless forced -> */ ";
@@ -301,7 +340,7 @@ export class SQLFragment<RunResult = pg.QueryResult['rows'], Constraint = never>
     return result;
   };
 
-  compileExpression = (expression: SQL, result: SQLQuery = { text: '', values: [] }, parentTable?: string, currentColumn?: Column) => {
+  compileExpression = (expression: GenericSQL, result: SQLQuery = { text: '', values: [] }, parentTable?: string, currentColumn?: Column<GenericSQLStructure>) => {
     if (this.parentTable) parentTable = this.parentTable;
 
     if (expression instanceof SQLFragment) {
@@ -380,7 +419,7 @@ export class SQLFragment<RunResult = pg.QueryResult['rows'], Constraint = never>
 
       } else {
         const
-          columnNames = <Column[]>Object.keys(expression.value).sort(),
+          columnNames = <Column<GenericSQLStructure>[]>Object.keys(expression.value).sort(),
           columnValues = columnNames.map(k => (<any>expression.value)[k]);
 
         for (let i = 0, len = columnValues.length; i < len; i++) {
@@ -397,7 +436,7 @@ export class SQLFragment<RunResult = pg.QueryResult['rows'], Constraint = never>
 
     } else if (typeof expression === 'object') {
       // must be a Whereable object, so put together a WHERE clause
-      const columnNames = <Column[]>Object.keys(expression).sort();
+      const columnNames = <Column<GenericSQLStructure>[]>Object.keys(expression).sort();
 
       if (columnNames.length) {  // if the object is not empty
         result.text += '(';
diff --git a/src/db/shortcuts.ts b/src/db/shortcuts.ts
index 3b3b828..83353fb 100644
--- a/src/db/shortcuts.ts
+++ b/src/db/shortcuts.ts
@@ -4,25 +4,13 @@ Copyright (C) 2020 - 2021 George MacKerron
 Released under the MIT licence: see LICENCE file
 */
 
-import type {
-  JSONSelectableForTable,
-  WhereableForTable,
-  InsertableForTable,
-  UpdatableForTable,
-  ColumnForTable,
-  UniqueIndexForTable,
-  SQLForTable,
-  Insertable,
-  Updatable,
-  Whereable,
-  Table,
-  Column,
-} from 'zapatos/schema';
-
 import {
   AllType,
   all,
-  SQL,
+  GenericSQL,
+  GenericSQLStructure,
+  SQLForStructure,
+  SQLStructure,
   SQLFragment,
   sql,
   cols,
@@ -30,6 +18,7 @@ import {
   raw,
   param,
   Default,
+  Column
 } from './core';
 
 import {
@@ -38,49 +27,50 @@ import {
 } from './utils';
 
 
-export type JSONOnlyColsForTable<T extends Table, C extends any[] /* `ColumnForTable<T>[]` gives errors here for reasons I haven't got to the bottom of */> =
-  Pick<JSONSelectableForTable<T>, C[number]>;
+export type JSONColumn <S extends GenericSQLStructure> = Exclude<keyof S['JSONSelectable'], number | symbol>;
+export type JSONOnlyColsForTable<S extends GenericSQLStructure, C extends JSONColumn<S>[]> =
+  Pick<S['JSONSelectable'], C[number]>;
 
 export interface SQLFragmentMap { [k: string]: SQLFragment<any> }
-export interface SQLFragmentOrColumnMap<T extends Table> { [k: string]: SQLFragment<any> | ColumnForTable<T> }
+export interface SQLFragmentOrColumnMap<S extends GenericSQLStructure> { [k: string]: SQLFragment<any> | Column<S> }
 export type RunResultForSQLFragment<T extends SQLFragment<any, any>> = T extends SQLFragment<infer RunResult, any> ? RunResult : never;
 
 export type LateralResult<L extends SQLFragmentMap> = { [K in keyof L]: RunResultForSQLFragment<L[K]> };
-export type ExtrasResult<T extends Table, E extends SQLFragmentOrColumnMap<T>> = { [K in keyof E]:
-  E[K] extends SQLFragment<any> ? RunResultForSQLFragment<E[K]> : E[K] extends keyof JSONSelectableForTable<T> ? JSONSelectableForTable<T>[E[K]] : never;
+export type ExtrasResult<S extends GenericSQLStructure, E extends SQLFragmentOrColumnMap<S>> = { [K in keyof E]:
+  E[K] extends SQLFragment<any> ? RunResultForSQLFragment<E[K]> : E[K] extends keyof S['JSONSelectable'] ? S['JSONSelectable'][E[K]] : never;
 };
 
-type ExtrasOption<T extends Table> = SQLFragmentOrColumnMap<T> | undefined;
-type ColumnsOption<T extends Table> = ColumnForTable<T>[] | undefined;
+type ExtrasOption<S extends GenericSQLStructure> = SQLFragmentOrColumnMap<S> | undefined;
+type ColumnsOption<S extends GenericSQLStructure> = Column<S>[] | undefined;
 
 type LimitedLateralOption = SQLFragmentMap | undefined;
 type FullLateralOption = LimitedLateralOption | SQLFragment<any>;
 type LateralOption<
-  C extends ColumnsOption<Table>,
-  E extends ExtrasOption<Table>,
+  C extends ColumnsOption<GenericSQLStructure>,
+  E extends ExtrasOption<GenericSQLStructure>,
   > =
   undefined extends C ? undefined extends E ? FullLateralOption : LimitedLateralOption : LimitedLateralOption;
 
-export interface ReturningOptionsForTable<T extends Table, C extends ColumnsOption<T>, E extends ExtrasOption<T>> {
+export interface ReturningOptionsForTable<S extends GenericSQLStructure, C extends ColumnsOption<S>, E extends ExtrasOption<S>> {
   returning?: C;
   extras?: E;
 };
 
-type ReturningTypeForTable<T extends Table, C extends ColumnsOption<T>, E extends ExtrasOption<T>> =
-  (undefined extends C ? JSONSelectableForTable<T> :
-    C extends ColumnForTable<T>[] ? JSONOnlyColsForTable<T, C> :
+type ReturningTypeForTable<S extends GenericSQLStructure, C extends JSONColumn<S>[] | undefined, E extends ExtrasOption<S>> =
+  (undefined extends C ? S['JSONSelectable'] :
+    C extends JSONColumn<S>[] ? JSONOnlyColsForTable<S, C> :
     never) &
   (undefined extends E ? {} :
-    E extends SQLFragmentOrColumnMap<T> ? ExtrasResult<T, E> :
+    E extends SQLFragmentOrColumnMap<S> ? ExtrasResult<S, E> :
     never);
 
 
-function SQLForColumnsOfTable(columns: Column[] | undefined, table: Table) {
+function SQLForColumnsOfTable(columns: Column<GenericSQLStructure>[] | undefined, table: GenericSQLStructure['Table']) {
   return columns === undefined ? sql`to_jsonb(${table}.*)` :
     sql`jsonb_build_object(${mapWithSeparator(columns, sql`, `, c => sql`${param(c)}::text, ${c}`)})`;
 }
 
-function SQLForExtras<T extends Table>(extras: ExtrasOption<T>) {
+function SQLForExtras<S extends GenericSQLStructure>(extras: ExtrasOption<S>) {
   return extras === undefined ? [] :
     sql` || jsonb_build_object(${mapWithSeparator(
       Object.keys(extras), sql`, `, k => sql`${param(k)}::text, ${extras[k]}`)})`;
@@ -89,30 +79,25 @@ function SQLForExtras<T extends Table>(extras: ExtrasOption<T>) {
 
 /* === insert === */
 
-interface InsertSignatures {
-  <T extends Table, C extends ColumnsOption<T>, E extends ExtrasOption<T>>(
+interface InsertSignatures <BaseSQLStructure extends GenericSQLStructure> {
+  <T extends BaseSQLStructure['Table'], S extends Extract<BaseSQLStructure, { Table: T }>, C extends ColumnsOption<S>, E extends ExtrasOption<S>>(
     table: T,
-    values: InsertableForTable<T>,
-    options?: ReturningOptionsForTable<T, C, E>
-  ): SQLFragment<ReturningTypeForTable<T, C, E>>;
+    values: S['Insertable'],
+    options?: ReturningOptionsForTable<S, C, E>
+  ): SQLFragment<ReturningTypeForTable<S, C, E>>;
 
-  <T extends Table, C extends ColumnsOption<T>, E extends ExtrasOption<T>>(
+  <T extends BaseSQLStructure['Table'], S extends Extract<BaseSQLStructure, { Table: T }>, C extends ColumnsOption<S>, E extends ExtrasOption<S>>(
     table: T,
-    values: InsertableForTable<T>[],
-    options?: ReturningOptionsForTable<T, C, E>
-  ): SQLFragment<ReturningTypeForTable<T, C, E>[]>;
+    values: S['Insertable'][],
+    options?: ReturningOptionsForTable<S, C, E>
+  ): SQLFragment<ReturningTypeForTable<S, C, E>[]>;
 }
 
-/**
- * Generate an `INSERT` query `SQLFragment`.
- * @param table The table into which to insert
- * @param values The `Insertable` values (or array thereof) to be inserted
- */
-export const insert: InsertSignatures = function (
-  table: Table,
-  values: Insertable | Insertable[],
-  options?: ReturningOptionsForTable<Table, ColumnsOption<Table>, ExtrasOption<Table>>
-): SQLFragment<any> {
+const genericInsert = (
+  table: GenericSQLStructure['Table'],
+  values: GenericSQLStructure['Insertable'] | GenericSQLStructure['Insertable'][],
+  options?: ReturningOptionsForTable<GenericSQLStructure, ColumnsOption<GenericSQLStructure>, ExtrasOption<GenericSQLStructure>>
+): SQLFragment<any> => {
 
   let query;
   if (Array.isArray(values) && values.length === 0) {
@@ -125,7 +110,7 @@ export const insert: InsertSignatures = function (
       completedValues = Array.isArray(values) ? completeKeysWithDefaultValue(values, Default) : values,
       colsSQL = cols(Array.isArray(completedValues) ? completedValues[0] : completedValues),
       valuesSQL = Array.isArray(completedValues) ?
-        mapWithSeparator(completedValues as Insertable[], sql`, `, v => sql`(${vals(v)})`) :
+        mapWithSeparator(completedValues as GenericSQLStructure['Insertable'][], sql`, `, v => sql`(${vals(v)})`) :
         sql`(${vals(completedValues)})`,
       returningSQL = SQLForColumnsOfTable(options?.returning, table),
       extrasSQL = SQLForExtras(options?.extras);
@@ -140,6 +125,13 @@ export const insert: InsertSignatures = function (
   return query;
 };
 
+/**
+ * Generate an `INSERT` query `SQLFragment`.
+ * @param table The table into which to insert
+ * @param values The `Insertable` values (or array thereof) to be inserted
+ */
+export const insert: InsertSignatures<SQLStructure> = genericInsert;
+
 
 /* === upsert === */
 
@@ -147,88 +139,78 @@ export const insert: InsertSignatures = function (
  * Wraps a unique index of the target table for use as the arbiter constraint
  * of an `upsert` shortcut query.
  */
-export class Constraint<T extends Table> { constructor(public value: UniqueIndexForTable<T>) { } }
+export class Constraint<S extends GenericSQLStructure> { constructor(public value: S['UniqueIndex']) { } }
 /**
  * Returns a `Constraint` instance, wrapping a unique index of the target table
  * for use as the arbiter constraint of an `upsert` shortcut query.
  */
-export function constraint<T extends Table>(x: UniqueIndexForTable<T>) { return new Constraint<T>(x); }
+export function constraint<S extends GenericSQLStructure>(x: S['UniqueIndex']) { return new Constraint<S>(x); }
 
 export interface UpsertAction { $action: 'INSERT' | 'UPDATE' }
 
 type UpsertReportAction = 'suppress';
 type UpsertReturnableForTable<
-  T extends Table,
-  C extends ColumnsOption<T>,
-  E extends ExtrasOption<T>,
+  S extends GenericSQLStructure,
+  C extends ColumnsOption<S>,
+  E extends ExtrasOption<S>,
   RA extends UpsertReportAction | undefined
   > =
-  ReturningTypeForTable<T, C, E> & (undefined extends RA ? UpsertAction : {});
+  ReturningTypeForTable<S, C, E> & (undefined extends RA ? UpsertAction : {});
 
-type UpsertConflictTargetForTable<T extends Table> = Constraint<T> | ColumnForTable<T> | ColumnForTable<T>[];
-type UpdateColumns<T extends Table> = ColumnForTable<T> | ColumnForTable<T>[];
+type UpsertConflictTargetForStructure<S extends GenericSQLStructure> = Constraint<S> | Column<S> | Column<S>[];
+type UpdateColumns<S extends GenericSQLStructure> = Column<S> | Column<S>[];
 
 interface UpsertOptions<
-  T extends Table,
-  C extends ColumnsOption<T>,
-  E extends ExtrasOption<T>,
-  UC extends UpdateColumns<T> | undefined,
+  S extends GenericSQLStructure,
+  C extends ColumnsOption<S>,
+  E extends ExtrasOption<S>,
+  UC extends UpdateColumns<S> | undefined,
   RA extends UpsertReportAction | undefined,
-  > extends ReturningOptionsForTable<T, C, E> {
-  updateValues?: UpdatableForTable<T>;
+  > extends ReturningOptionsForTable<S, C, E> {
+  updateValues?: S['Updatable'];
   updateColumns?: UC;
-  noNullUpdateColumns?: ColumnForTable<T> | ColumnForTable<T>[];
+  noNullUpdateColumns?: Column<S> | Column<S>[];
   reportAction?: RA;
 }
 
-interface UpsertSignatures {
-  <T extends Table,
-    C extends ColumnsOption<T>,
-    E extends ExtrasOption<T>,
-    UC extends UpdateColumns<T> | undefined,
+interface UpsertSignatures <BaseSQLStructure extends GenericSQLStructure> {
+  <T extends BaseSQLStructure['Table'],
+    S extends Extract<BaseSQLStructure, { Table: T }>,
+    C extends ColumnsOption<S>,
+    E extends ExtrasOption<S>,
+    UC extends UpdateColumns<S> | undefined,
     RA extends UpsertReportAction | undefined
     >(
     table: T,
-    values: InsertableForTable<T>,
-    conflictTarget: UpsertConflictTargetForTable<T>,
-    options?: UpsertOptions<T, C, E, UC, RA>
-  ): SQLFragment<UpsertReturnableForTable<T, C, E, RA> | (UC extends never[] ? undefined : never)>;
-
-  <T extends Table,
-    C extends ColumnsOption<T>,
-    E extends ExtrasOption<T>,
-    UC extends UpdateColumns<T> | undefined,
+    values: S['Insertable'],
+    conflictTarget: UpsertConflictTargetForStructure<S>,
+    options?: UpsertOptions<S, C, E, UC, RA>
+  ): SQLFragment<UpsertReturnableForTable<S, C, E, RA> | (UC extends never[] ? undefined : never)>;
+
+  <T extends BaseSQLStructure['Table'],
+    S extends Extract<BaseSQLStructure, { Table: T }>,
+    C extends ColumnsOption<S>,
+    E extends ExtrasOption<S>,
+    UC extends UpdateColumns<S> | undefined,
     RA extends UpsertReportAction | undefined
     >(
     table: T,
-    values: InsertableForTable<T>[],
-    conflictTarget: UpsertConflictTargetForTable<T>,
-    options?: UpsertOptions<T, C, E, UC, RA>
-  ): SQLFragment<UpsertReturnableForTable<T, C, E, RA>[]>;
+    values: S['Insertable'][],
+    conflictTarget: UpsertConflictTargetForStructure<S>,
+    options?: UpsertOptions<S, C, E, UC, RA>
+  ): SQLFragment<UpsertReturnableForTable<S, C, E, RA>[]>;
 }
 
 export const doNothing = [];
 
-/**
- * Generate an 'upsert' (`INSERT ... ON CONFLICT ...`) query `SQLFragment`.
- * @param table The table to update or insert into
- * @param values An `Insertable` of values (or an array thereof) to be inserted 
- * or updated
- * @param conflictTarget A `UNIQUE`-indexed column (or array thereof) or a 
- * `UNIQUE` index (wrapped in `db.constraint(...)`) that determines whether we
- * get an `UPDATE` (when there's a matching existing value) or an `INSERT`
- * (when there isn't)
- * @param options Optionally, an object with any of the keys `updateColumns`,
- * `noNullUpdateColumns` and `updateValues` (see documentation).
- */
-export const upsert: UpsertSignatures = function (
-  table: Table,
-  values: Insertable | Insertable[],
-  conflictTarget: Column | Column[] | Constraint<Table>,
-  options?: UpsertOptions<Table, ColumnsOption<Table>, ExtrasOption<Table>, UpdateColumns<Table>, UpsertReportAction>
+const genericUpsert = function (
+  table: GenericSQLStructure['Table'],
+  values: GenericSQLStructure['Insertable'] | GenericSQLStructure['Insertable'][],
+  conflictTarget: Column<GenericSQLStructure> | Column<GenericSQLStructure>[] | Constraint<GenericSQLStructure>,
+  options?: UpsertOptions<any, ColumnsOption<GenericSQLStructure>, ExtrasOption<GenericSQLStructure>, UpdateColumns<GenericSQLStructure>, UpsertReportAction>
 ): SQLFragment<any> {
 
-  if (Array.isArray(values) && values.length === 0) return insert(table, values);  // punt a no-op to plain insert
+  if (Array.isArray(values) && values.length === 0) return genericInsert(table, values);  // punt a no-op to plain insert
   if (typeof conflictTarget === 'string') conflictTarget = [conflictTarget];  // now either Column[] or Constraint
 
   let noNullUpdateColumns = options?.noNullUpdateColumns ?? [];
@@ -242,7 +224,7 @@ export const upsert: UpsertSignatures = function (
     firstRow = completedValues[0],
     insertColsSQL = cols(firstRow),
     insertValuesSQL = mapWithSeparator(completedValues, sql`, `, v => sql`(${vals(v)})`),
-    colNames = Object.keys(firstRow) as Column[],
+    colNames = Object.keys(firstRow) as Column<GenericSQLStructure>[],
     updateColumns = specifiedUpdateColumns as string[] ?? colNames,
     conflictTargetSQL = Array.isArray(conflictTarget) ?
       sql`(${mapWithSeparator(conflictTarget, sql`, `, c => c)})` :
@@ -250,9 +232,11 @@ export const upsert: UpsertSignatures = function (
     updateColsSQL = mapWithSeparator(updateColumns, sql`, `, c => c),
     updateValues = options?.updateValues ?? {},
     updateValuesSQL = mapWithSeparator(updateColumns, sql`, `, c =>
-      updateValues[c] !== undefined ? updateValues[c] :
-        noNullUpdateColumns.includes(c) ? sql`CASE WHEN EXCLUDED.${c} IS NULL THEN ${table}.${c} ELSE EXCLUDED.${c} END` :
-          sql`EXCLUDED.${c}`),
+      (updateValues as { [k: string]: any })[c] !== undefined
+        ? (updateValues as { [k: string]: any })[c]
+        : noNullUpdateColumns.includes(c)
+          ? sql`CASE WHEN EXCLUDED.${c} IS NULL THEN ${table}.${c} ELSE EXCLUDED.${c} END`
+          : sql`EXCLUDED.${c}`),
     returningSQL = SQLForColumnsOfTable(options?.returning, table),
     extrasSQL = SQLForExtras(options?.extras),
     suppressReport = options?.reportAction === 'suppress';
@@ -275,29 +259,37 @@ export const upsert: UpsertSignatures = function (
   return query;
 };
 
+/**
+ * Generate an 'upsert' (`INSERT ... ON CONFLICT ...`) query `SQLFragment`.
+ * @param table The table to update or insert into
+ * @param values An `Insertable` of values (or an array thereof) to be inserted 
+ * or updated
+ * @param conflictTarget A `UNIQUE`-indexed column (or array thereof) or a 
+ * `UNIQUE` index (wrapped in `db.constraint(...)`) that determines whether we
+ * get an `UPDATE` (when there's a matching existing value) or an `INSERT`
+ * (when there isn't)
+ * @param options Optionally, an object with any of the keys `updateColumns`,
+ * `noNullUpdateColumns` and `updateValues` (see documentation).
+ */
+export const upsert: UpsertSignatures<SQLStructure> = genericUpsert;
+
 
 /* === update === */
 
-interface UpdateSignatures {
-  <T extends Table, C extends ColumnsOption<T>, E extends ExtrasOption<T>>(
+interface UpdateSignatures <BaseSQLStructure extends GenericSQLStructure> {
+  <T extends BaseSQLStructure['Table'], S extends Extract<BaseSQLStructure, { Table: T }>, C extends ColumnsOption<S>, E extends ExtrasOption<S>>(
     table: T,
-    values: UpdatableForTable<T>,
-    where: WhereableForTable<T> | SQLFragment,
-    options?: ReturningOptionsForTable<T, C, E>
-  ): SQLFragment<ReturningTypeForTable<T, C, E>[]>;
+    values: S['Updatable'],
+    where: S['Whereable'] | SQLFragment,
+    options?: ReturningOptionsForTable<S, C, E>
+  ): SQLFragment<ReturningTypeForTable<S, C, E>[]>;
 }
 
-/**
- * Generate an `UPDATE` query `SQLFragment`.
- * @param table The table to update
- * @param values An `Updatable` of the new values with which to update the table
- * @param where A `Whereable` (or `SQLFragment`) defining which rows to update
- */
-export const update: UpdateSignatures = function (
-  table: Table,
-  values: Updatable,
-  where: Whereable | SQLFragment,
-  options?: ReturningOptionsForTable<Table, ColumnsOption<Table>, ExtrasOption<Table>>
+const genericUpdate = function (
+  table: GenericSQLStructure['Table'],
+  values: GenericSQLStructure['Updatable'],
+  where: GenericSQLStructure['Whereable'] | SQLFragment,
+  options?: ReturningOptionsForTable<GenericSQLStructure, ColumnsOption<GenericSQLStructure>, ExtrasOption<GenericSQLStructure>>
 ): SQLFragment {
 
   // note: the ROW() constructor below is required in Postgres 10+ if we're updating a single column
@@ -306,150 +298,168 @@ export const update: UpdateSignatures = function (
   const
     returningSQL = SQLForColumnsOfTable(options?.returning, table),
     extrasSQL = SQLForExtras(options?.extras),
-    query = sql`UPDATE ${table} SET (${cols(values)}) = ROW(${vals(values)}) WHERE ${where} RETURNING ${returningSQL}${extrasSQL} AS result`;
+    query = sql<GenericSQL>`UPDATE ${table} SET (${cols(values)}) = ROW(${vals(values)}) WHERE ${where} RETURNING ${returningSQL}${extrasSQL} AS result`;
 
   query.runResultTransform = (qr) => qr.rows.map(r => r.result);
   return query;
 };
 
+/**
+ * Generate an `UPDATE` query `SQLFragment`.
+ * @param table The table to update
+ * @param values An `Updatable` of the new values with which to update the table
+ * @param where A `Whereable` (or `SQLFragment`) defining which rows to update
+ */
+export const update: UpdateSignatures<SQLStructure> = genericUpdate;
+
 
 /* === delete === */
 
-export interface DeleteSignatures {
-  <T extends Table, C extends ColumnsOption<T>, E extends ExtrasOption<T>>(
+export interface DeleteSignatures <BaseSQLStructure extends GenericSQLStructure> {
+  <T extends BaseSQLStructure['Table'], S extends Extract<BaseSQLStructure, { Table: T }>, C extends ColumnsOption<S>, E extends ExtrasOption<S>>(
     table: T,
-    where: WhereableForTable<T> | SQLFragment,
-    options?: ReturningOptionsForTable<T, C, E>
-  ): SQLFragment<ReturningTypeForTable<T, C, E>[]>;
+    where: S['Whereable'] | SQLFragment,
+    options?: ReturningOptionsForTable<S, C, E>
+  ): SQLFragment<ReturningTypeForTable<S, C, E>[]>;
 }
 
-/**
- * Generate an `DELETE` query `SQLFragment` (plain 'delete' is a reserved word)
- * @param table The table to delete from
- * @param where A `Whereable` (or `SQLFragment`) defining which rows to delete
- */
-export const deletes: DeleteSignatures = function (
-  table: Table,
-  where: Whereable | SQLFragment,
-  options?: ReturningOptionsForTable<Table, ColumnsOption<Table>, ExtrasOption<Table>>
+const genericDeletes = function (
+  table: GenericSQLStructure['Table'],
+  where: GenericSQLStructure['Whereable'] | SQLFragment,
+  options?: ReturningOptionsForTable<GenericSQLStructure, ColumnsOption<GenericSQLStructure>, ExtrasOption<GenericSQLStructure>>
 ): SQLFragment {
 
   const
     returningSQL = SQLForColumnsOfTable(options?.returning, table),
     extrasSQL = SQLForExtras(options?.extras),
-    query = sql`DELETE FROM ${table} WHERE ${where} RETURNING ${returningSQL}${extrasSQL} AS result`;
+    query = sql<GenericSQL>`DELETE FROM ${table} WHERE ${where} RETURNING ${returningSQL}${extrasSQL} AS result`;
 
   query.runResultTransform = (qr) => qr.rows.map(r => r.result);
   return query;
 };
 
+/**
+ * Generate an `DELETE` query `SQLFragment` (plain 'delete' is a reserved word)
+ * @param table The table to delete from
+ * @param where A `Whereable` (or `SQLFragment`) defining which rows to delete
+ */
+export const deletes: DeleteSignatures<SQLStructure> = genericDeletes;
+
 
 /* === truncate === */
 
 type TruncateIdentityOpts = 'CONTINUE IDENTITY' | 'RESTART IDENTITY';
 type TruncateForeignKeyOpts = 'RESTRICT' | 'CASCADE';
 
-interface TruncateSignatures {
-  (table: Table | Table[]): SQLFragment<undefined>;
-  (table: Table | Table[], optId: TruncateIdentityOpts): SQLFragment<undefined>;
-  (table: Table | Table[], optFK: TruncateForeignKeyOpts): SQLFragment<undefined>;
-  (table: Table | Table[], optId: TruncateIdentityOpts, optFK: TruncateForeignKeyOpts): SQLFragment<undefined>;
+interface TruncateSignatures <BaseSQLStructure extends GenericSQLStructure> {
+  <T extends BaseSQLStructure['Table']>(table: T | T[]): SQLFragment<undefined>;
+  <T extends BaseSQLStructure['Table']>(table: T | T[], optId: TruncateIdentityOpts): SQLFragment<undefined>;
+  <T extends BaseSQLStructure['Table']>(table: T | T[], optFK: TruncateForeignKeyOpts): SQLFragment<undefined>;
+  <T extends BaseSQLStructure['Table']>(table: T | T[], optId: TruncateIdentityOpts, optFK: TruncateForeignKeyOpts): SQLFragment<undefined>;
 }
 
-/**
- * Generate a `TRUNCATE` query `SQLFragment`.
- * @param table The table (or array thereof) to truncate
- * @param opts Options: 'CONTINUE IDENTITY'/'RESTART IDENTITY' and/or 
- * 'RESTRICT'/'CASCADE'
- */
-export const truncate: TruncateSignatures = function (
-  table: Table | Table[],
+const genericTruncate = function (
+  table: GenericSQLStructure['Table'] | GenericSQLStructure['Table'][],
   ...opts: string[]
 ): SQLFragment<undefined> {
 
   if (!Array.isArray(table)) table = [table];
   const
     tables = mapWithSeparator(table, sql`, `, t => t),
-    query = sql<SQL, undefined>`TRUNCATE ${tables}${raw((opts.length ? ' ' : '') + opts.join(' '))}`;
+    query = sql<GenericSQL, undefined>`TRUNCATE ${tables}${raw((opts.length ? ' ' : '') + opts.join(' '))}`;
 
   return query;
 };
 
+/**
+ * Generate a `TRUNCATE` query `SQLFragment`.
+ * @param table The table (or array thereof) to truncate
+ * @param opts Options: 'CONTINUE IDENTITY'/'RESTART IDENTITY' and/or 
+ * 'RESTRICT'/'CASCADE'
+ */
+export const truncate: TruncateSignatures<SQLStructure> = genericTruncate;
+
 
 /* === select === */
 
-interface OrderSpecForTable<T extends Table> {
-  by: SQLForTable<T>;
+interface OrderSpecForTable<S extends GenericSQLStructure> {
+  by: SQLForStructure<S>;
   direction: 'ASC' | 'DESC';
   nulls?: 'FIRST' | 'LAST';
 }
 
-export interface SelectLockingOptions {
+export interface SelectLockingOptions<O extends GenericSQLStructure> {
   for: 'UPDATE' | 'NO KEY UPDATE' | 'SHARE' | 'KEY SHARE';
-  of?: Table | Table[];
+  of?: O['Table'] | O['Table'][];
   wait?: 'NOWAIT' | 'SKIP LOCKED';
 }
 
 export interface SelectOptionsForTable<
-  T extends Table,
-  C extends ColumnsOption<T>,
+  S extends GenericSQLStructure,
+  O extends GenericSQLStructure,
+  C extends ColumnsOption<S>,
   L extends LateralOption<C, E>,
-  E extends ExtrasOption<T>,
+  E extends ExtrasOption<S>,
   > {
-  distinct?: boolean | ColumnForTable<T> | ColumnForTable<T>[] | SQLFragment<any>;
-  order?: OrderSpecForTable<T> | OrderSpecForTable<T>[];
+  distinct?: boolean | Column<S> | Column<S>[] | SQLFragment<any>;
+  order?: OrderSpecForTable<S> | OrderSpecForTable<S>[];
   limit?: number;
   offset?: number;
   withTies?: boolean;
   columns?: C;
   extras?: E;
-  groupBy?: ColumnForTable<T> | ColumnForTable<T>[] | SQLFragment<any>;
-  having?: WhereableForTable<T> | SQLFragment<any>;
+  groupBy?: Column<S> | Column<S>[] | SQLFragment<any>;
+  having?: S['Whereable'] | SQLFragment<any>;
   lateral?: L;
   alias?: string;
-  lock?: SelectLockingOptions | SelectLockingOptions[];
+  lock?: SelectLockingOptions<O> | SelectLockingOptions<O>[];
 };
 
 type SelectReturnTypeForTable<
-  T extends Table,
-  C extends ColumnsOption<T>,
+  S extends GenericSQLStructure,
+  C extends ColumnsOption<S>,
   L extends LateralOption<C, E>,
-  E extends ExtrasOption<T>,
+  E extends ExtrasOption<S>,
   > =
-  (undefined extends L ? ReturningTypeForTable<T, C, E> :
-    L extends SQLFragmentMap ? ReturningTypeForTable<T, C, E> & LateralResult<L> :
+  (undefined extends L ? ReturningTypeForTable<S, C, E> :
+    L extends SQLFragmentMap ? ReturningTypeForTable<S, C, E> & LateralResult<L> :
     L extends SQLFragment<any> ? RunResultForSQLFragment<L> :
     never);
 
 export enum SelectResultMode { Many, One, ExactlyOne, Numeric }
 
 export type FullSelectReturnTypeForTable<
-  T extends Table,
-  C extends ColumnsOption<T>,
+  S extends GenericSQLStructure,
+  C extends ColumnsOption<S>,
   L extends LateralOption<C, E>,
-  E extends ExtrasOption<T>,
+  E extends ExtrasOption<S>,
   M extends SelectResultMode,
   > =
   {
-    [SelectResultMode.Many]: SelectReturnTypeForTable<T, C, L, E>[];
-    [SelectResultMode.ExactlyOne]: SelectReturnTypeForTable<T, C, L, E>;
-    [SelectResultMode.One]: SelectReturnTypeForTable<T, C, L, E> | undefined;
+    [SelectResultMode.Many]: SelectReturnTypeForTable<S, C, L, E>[];
+    [SelectResultMode.ExactlyOne]: SelectReturnTypeForTable<S, C, L, E>;
+    [SelectResultMode.One]: SelectReturnTypeForTable<S, C, L, E> | undefined;
     [SelectResultMode.Numeric]: number;
   }[M];
 
-export interface SelectSignatures {
-  <T extends Table,
-    C extends ColumnsOption<T>,
+export interface SelectSignatures <
+  BaseSQLStructure extends GenericSQLStructure,
+  OtherSQLStructure extends GenericSQLStructure
+  > {
+  <T extends BaseSQLStructure['Table'],
+    S extends Extract<BaseSQLStructure, { Table: T }>,
+    O extends OtherSQLStructure,
+    C extends ColumnsOption<S>,
     L extends LateralOption<C, E>,
-    E extends ExtrasOption<T>,
+    E extends ExtrasOption<S>,
     M extends SelectResultMode = SelectResultMode.Many
     >(
     table: T,
-    where: WhereableForTable<T> | SQLFragment | AllType,
-    options?: SelectOptionsForTable<T, C, L, E>,
+    where: S['Whereable'] | SQLFragment | AllType,
+    options?: SelectOptionsForTable<S, O, C, L, E>,
     mode?: M,
     aggregate?: string,
-  ): SQLFragment<FullSelectReturnTypeForTable<T, C, L, E, M>>;
+  ): SQLFragment<FullSelectReturnTypeForTable<S, C, L, E, M>>;
 }
 
 export class NotExactlyOneError extends Error {
@@ -463,31 +473,10 @@ export class NotExactlyOneError extends Error {
   }
 }
 
-/**
- * Generate a `SELECT` query `SQLFragment`. This can be nested with other 
- * `select`/`selectOne`/`count` queries using the `lateral` option.
- * @param table The table to select from
- * @param where A `Whereable` or `SQLFragment` defining the rows to be selected,
- * or `all`
- * @param options Options object. Keys (all optional) are: 
- * * `columns` — an array of column names: only these columns will be returned
- * * `order` – an array of `OrderSpec` objects, such as 
- * `{ by: 'column', direction: 'ASC' }`  
- * * `limit` and `offset` – numbers: apply this limit and offset to the query
- * * `lateral` — either an object mapping keys to nested `select`/`selectOne`/
- * `count` queries to be `LATERAL JOIN`ed, or a single `select`/`selectOne`/
- * `count` query whose result will be passed through directly as the result of
- * the containing query
- * * `alias` — table alias (string): required if using `lateral` to join a table
- * to itself
- * * `extras` — an object mapping key(s) to `SQLFragment`s, so that derived 
- * quantities can be included in the JSON result
- * @param mode (Used internally by `selectOne` and `count`)
- */
-export const select: SelectSignatures = function (
-  table: Table,
-  where: Whereable | SQLFragment | AllType = all,
-  options: SelectOptionsForTable<Table, ColumnsOption<Table>, LateralOption<ColumnsOption<Table>, ExtrasOption<Table>>, ExtrasOption<Table>> = {},
+const genericSelect = function (
+  table: GenericSQLStructure['Table'],
+  where: GenericSQLStructure['Whereable'] | SQLFragment | AllType = all,
+  options: SelectOptionsForTable<any, GenericSQLStructure, ColumnsOption<GenericSQLStructure>, LateralOption<ColumnsOption<GenericSQLStructure>, ExtrasOption<GenericSQLStructure>>, ExtrasOption<GenericSQLStructure>> = {},
   mode: SelectResultMode = SelectResultMode.Many,
   aggregate: string = 'count',
 ) {
@@ -505,30 +494,30 @@ export const select: SelectSignatures = function (
     colsSQL = lateral instanceof SQLFragment ? [] :
       mode === SelectResultMode.Numeric ?
         (columns ? sql`${raw(aggregate)}(${cols(columns)})` : sql`${raw(aggregate)}(${alias}.*)`) :
-        SQLForColumnsOfTable(columns, alias as Table),
+        SQLForColumnsOfTable(columns, alias as GenericSQLStructure['Table']),
     colsExtraSQL = lateral instanceof SQLFragment || mode === SelectResultMode.Numeric ? [] : SQLForExtras(extras),
     colsLateralSQL = lateral === undefined || mode === SelectResultMode.Numeric ? [] :
       lateral instanceof SQLFragment ? sql`"ljoin_passthru".result` :
         sql` || jsonb_build_object(${mapWithSeparator(
           Object.keys(lateral).sort(), sql`, `, (k, i) => sql`${param(k)}::text, "ljoin_${raw(String(i))}".result`)})`,
     allColsSQL = sql`${colsSQL}${colsExtraSQL}${colsLateralSQL}`,
-    whereSQL = where === all ? [] : sql` WHERE ${where}`,
+    whereSQL = where === all ? [] : sql<GenericSQL>` WHERE ${where}`,
     groupBySQL = !groupBy ? [] : sql` GROUP BY ${groupBy instanceof SQLFragment || typeof groupBy === 'string' ? groupBy : cols(groupBy)}`,
     havingSQL = !having ? [] : sql` HAVING ${having}`,
     orderSQL = order === undefined ? [] :
-      sql` ORDER BY ${mapWithSeparator(order as OrderSpecForTable<Table>[], sql`, `, o => {  // `as` clause is required when TS not strict
+      sql` ORDER BY ${mapWithSeparator(order as OrderSpecForTable<GenericSQLStructure>[], sql`, `, o => {  // `as` clause is required when TS not strict
         if (!['ASC', 'DESC'].includes(o.direction)) throw new Error(`Direction must be ASC/DESC, not '${o.direction}'`);
         if (o.nulls && !['FIRST', 'LAST'].includes(o.nulls)) throw new Error(`Nulls must be FIRST/LAST/undefined, not '${o.nulls}'`);
-        return sql`${o.by} ${raw(o.direction)}${o.nulls ? sql` NULLS ${raw(o.nulls)}` : []}`;
+        return sql<GenericSQL>`${o.by} ${raw(o.direction)}${o.nulls ? sql` NULLS ${raw(o.nulls)}` : []}`;
       })}`,
     limitSQL = allOptions.limit === undefined ? [] :
       allOptions.withTies ? sql` FETCH FIRST ${param(allOptions.limit)} ROWS WITH TIES` :
         sql` LIMIT ${param(allOptions.limit)}`,  // compatibility with pg pre-10.5; and fewer bytes!
     offsetSQL = allOptions.offset === undefined ? [] : sql` OFFSET ${param(allOptions.offset)}`,  // pg is lax about OFFSET following FETCH, and we exploit that
-    lockSQL = lock === undefined ? [] : (lock as SelectLockingOptions[]).map(lock => {  // `as` clause is required when TS not strict
+    lockSQL = lock === undefined ? [] : (lock as SelectLockingOptions<GenericSQLStructure>[]).map(lock => {  // `as` clause is required when TS not strict
       const
         ofTables = lock.of === undefined || Array.isArray(lock.of) ? lock.of : [lock.of],
-        ofClause = ofTables === undefined ? [] : sql` OF ${mapWithSeparator(ofTables as Table[], sql`, `, t => t)}`;  // `as` clause is required when TS not strict
+        ofClause = ofTables === undefined ? [] : sql` OF ${mapWithSeparator(ofTables as GenericSQLStructure['Table'][], sql`, `, t => t)}`;  // `as` clause is required when TS not strict
       return sql` FOR ${raw(lock.for)}${ofClause}${lock.wait ? sql` ${raw(lock.wait)}` : []}`;
     }),
     lateralSQL = lateral === undefined ? [] :
@@ -543,10 +532,10 @@ export const select: SelectSignatures = function (
         });
 
   const
-    rowsQuery = sql<SQL, any>`SELECT${distinctSQL} ${allColsSQL} AS result FROM ${table}${tableAliasSQL}${lateralSQL}${whereSQL}${groupBySQL}${havingSQL}${orderSQL}${limitSQL}${offsetSQL}${lockSQL}`,
+    rowsQuery = sql<GenericSQL, any>`SELECT${distinctSQL} ${allColsSQL} AS result FROM ${table}${tableAliasSQL}${lateralSQL}${whereSQL}${groupBySQL}${havingSQL}${orderSQL}${limitSQL}${offsetSQL}${lockSQL}`,
     query = mode !== SelectResultMode.Many ? rowsQuery :
       // we need the aggregate to sit in a sub-SELECT in order to keep ORDER and LIMIT working as usual
-      sql<SQL, any>`SELECT coalesce(jsonb_agg(result), '[]') AS result FROM (${rowsQuery}) AS ${raw(`"sq_${alias}"`)}`;
+      sql<GenericSQL, any>`SELECT coalesce(jsonb_agg(result), '[]') AS result FROM (${rowsQuery}) AS ${raw(`"sq_${alias}"`)}`;
 
   query.runResultTransform =
 
@@ -567,22 +556,66 @@ export const select: SelectSignatures = function (
   return query;
 };
 
+/**
+ * Generate a `SELECT` query `SQLFragment`. This can be nested with other 
+ * `select`/`selectOne`/`count` queries using the `lateral` option.
+ * @param table The table to select from
+ * @param where A `Whereable` or `SQLFragment` defining the rows to be selected,
+ * or `all`
+ * @param options Options object. Keys (all optional) are: 
+ * * `columns` — an array of column names: only these columns will be returned
+ * * `order` – an array of `OrderSpec` objects, such as 
+ * `{ by: 'column', direction: 'ASC' }`  
+ * * `limit` and `offset` – numbers: apply this limit and offset to the query
+ * * `lateral` — either an object mapping keys to nested `select`/`selectOne`/
+ * `count` queries to be `LATERAL JOIN`ed, or a single `select`/`selectOne`/
+ * `count` query whose result will be passed through directly as the result of
+ * the containing query
+ * * `alias` — table alias (string): required if using `lateral` to join a table
+ * to itself
+ * * `extras` — an object mapping key(s) to `SQLFragment`s, so that derived 
+ * quantities can be included in the JSON result
+ * @param mode (Used internally by `selectOne` and `count`)
+ */
+
+export const select: SelectSignatures<SQLStructure, SQLStructure> = genericSelect;
+
 
 /* === selectOne === */
 
-export interface SelectOneSignatures {
+export interface SelectOneSignatures <
+  BaseSQLStructure extends GenericSQLStructure,
+  OtherSQLStructure extends GenericSQLStructure
+  > {
   <
-    T extends Table,
-    C extends ColumnsOption<T>,
+    T extends BaseSQLStructure['Table'],
+    S extends Extract<BaseSQLStructure, { Table: T }>,
+    O extends OtherSQLStructure,
+    C extends ColumnsOption<S>,
     L extends LateralOption<C, E>,
-    E extends ExtrasOption<T>,
+    E extends ExtrasOption<S>,
     >(
     table: T,
-    where: WhereableForTable<T> | SQLFragment | AllType,
-    options?: SelectOptionsForTable<T, C, L, E>,
-  ): SQLFragment<FullSelectReturnTypeForTable<T, C, L, E, SelectResultMode.One>>;
+    where: S['Whereable'] | SQLFragment | AllType,
+    options?: SelectOptionsForTable<S, O, C, L, E>,
+  ): SQLFragment<FullSelectReturnTypeForTable<S, C, L, E, SelectResultMode.One>>;
 }
 
+const genericSelectOne = function (
+  table: GenericSQLStructure['Table'],
+  where: GenericSQLStructure['Whereable'] | SQLFragment | AllType,
+  options: SelectOptionsForTable<any, GenericSQLStructure, ColumnsOption<GenericSQLStructure>, LateralOption<ColumnsOption<GenericSQLStructure>, ExtrasOption<GenericSQLStructure>>, ExtrasOption<GenericSQLStructure>> = {}
+): SQLFragment<any> {
+  // you might argue that 'selectOne' offers little that you can't get with 
+  // destructuring assignment and plain 'select' 
+  // -- e.g.let[x] = async select(...).run(pool); -- but something worth having
+  // is '| undefined' in the return signature, because the result of indexing 
+  // never includes undefined (until 4.1 and --noUncheckedIndexedAccess)
+  // (see https://github.com/Microsoft/TypeScript/issues/13778)
+
+  return genericSelect(table, where, options, SelectResultMode.One);
+};
+
 /**
  * Generate a `SELECT` query `SQLFragment` that returns only a single result (or 
  * undefined). A `LIMIT 1` clause is added automatically. This can be nested with 
@@ -592,33 +625,37 @@ export interface SelectOneSignatures {
  * or `all`
  * @param options Options object. See documentation for `select` for details.
  */
-export const selectOne: SelectOneSignatures = function (table, where, options = {}) {
-  // you might argue that 'selectOne' offers little that you can't get with 
-  // destructuring assignment and plain 'select' 
-  // -- e.g.let[x] = async select(...).run(pool); -- but something worth having
-  // is '| undefined' in the return signature, because the result of indexing 
-  // never includes undefined (until 4.1 and --noUncheckedIndexedAccess)
-  // (see https://github.com/Microsoft/TypeScript/issues/13778)
-
-  return select(table, where, options, SelectResultMode.One);
-};
+export const selectOne: SelectOneSignatures<SQLStructure, SQLStructure> = genericSelectOne;
 
 
 /* === selectExactlyOne === */
 
-export interface SelectExactlyOneSignatures {
+export interface SelectExactlyOneSignatures <
+  BaseSQLStructure extends GenericSQLStructure,
+  OtherSQLStructure extends GenericSQLStructure
+  > {
   <
-    T extends Table,
-    C extends ColumnsOption<T>,
+    T extends BaseSQLStructure['Table'],
+    S extends Extract<BaseSQLStructure, { Table: T }>,
+    O extends OtherSQLStructure,
+    C extends ColumnsOption<S>,
     L extends LateralOption<C, E>,
-    E extends ExtrasOption<T>,
+    E extends ExtrasOption<S>,
     >(
     table: T,
-    where: WhereableForTable<T> | SQLFragment | AllType,
-    options?: SelectOptionsForTable<T, C, L, E>,
-  ): SQLFragment<FullSelectReturnTypeForTable<T, C, L, E, SelectResultMode.ExactlyOne>>;
+    where: S['Whereable'] | SQLFragment | AllType,
+    options?: SelectOptionsForTable<S, O, C, L, E>,
+  ): SQLFragment<FullSelectReturnTypeForTable<S, C, L, E, SelectResultMode.ExactlyOne>>;
 }
 
+export const genericSelectExactlyOne = function (
+  table: GenericSQLStructure['Table'],
+  where: GenericSQLStructure['Whereable'] | SQLFragment | AllType,
+  options: SelectOptionsForTable<any, GenericSQLStructure, ColumnsOption<GenericSQLStructure>, LateralOption<ColumnsOption<GenericSQLStructure>, ExtrasOption<GenericSQLStructure>>, ExtrasOption<GenericSQLStructure>> = {}
+): SQLFragment<any> {
+  return genericSelect(table, where, options, SelectResultMode.ExactlyOne);
+};
+
 /**
  * Generate a `SELECT` query `SQLFragment` that returns a single result or 
  * throws an error. A `LIMIT 1` clause is added automatically. This can be 
@@ -630,26 +667,37 @@ export interface SelectExactlyOneSignatures {
  * @param options Options object. See documentation for `select` for details.
  */
 
-export const selectExactlyOne: SelectExactlyOneSignatures = function (table, where, options = {}) {
-  return select(table, where, options, SelectResultMode.ExactlyOne);
-};
+export const selectExactlyOne: SelectExactlyOneSignatures<SQLStructure, SQLStructure> = genericSelectExactlyOne;
 
 
 /* === count, sum, avg === */
 
-export interface NumericAggregateSignatures {
+export interface NumericAggregateSignatures <
+  BaseSQLStructure extends GenericSQLStructure,
+  OtherSQLStructure extends GenericSQLStructure
+  > {
   <
-    T extends Table,
-    C extends ColumnsOption<T>,
+    T extends BaseSQLStructure['Table'],
+    S extends Extract<BaseSQLStructure, { Table: T }>,
+    O extends OtherSQLStructure,
+    C extends ColumnsOption<S>,
     L extends LateralOption<C, E>,
-    E extends ExtrasOption<T>,
+    E extends ExtrasOption<S>,
     >(
     table: T,
-    where: WhereableForTable<T> | SQLFragment | AllType,
-    options?: SelectOptionsForTable<T, C, L, E>,
+    where: S['Whereable'] | SQLFragment | AllType,
+    options?: SelectOptionsForTable<S, O, C, L, E>,
   ): SQLFragment<number>;
 }
 
+export const genericCount = function (
+  table: GenericSQLStructure['Table'],
+  where: GenericSQLStructure['Whereable'] | SQLFragment | AllType,
+  options?: SelectOptionsForTable<any, GenericSQLStructure, ColumnsOption<GenericSQLStructure>, LateralOption<ColumnsOption<GenericSQLStructure>, ExtrasOption<GenericSQLStructure>>, ExtrasOption<GenericSQLStructure>>
+) {
+  return genericSelect(table, where, options, SelectResultMode.Numeric);
+};
+
 /**
  * Generate a `SELECT` query `SQLFragment` that returns a count. This can be 
  * nested in other `select`/`selectOne` queries using their `lateral` option.
@@ -658,8 +706,14 @@ export interface NumericAggregateSignatures {
  * or `all`
  * @param options Options object. Useful keys may be: `columns`, `alias`.
  */
-export const count: NumericAggregateSignatures = function (table, where, options?) {
-  return select(table, where, options, SelectResultMode.Numeric);
+export const count: NumericAggregateSignatures<SQLStructure, SQLStructure> = genericCount;
+
+export const genericSum = function (
+  table: GenericSQLStructure['Table'],
+  where: GenericSQLStructure['Whereable'] | SQLFragment | AllType,
+  options?: SelectOptionsForTable<any, GenericSQLStructure, ColumnsOption<GenericSQLStructure>, LateralOption<ColumnsOption<GenericSQLStructure>, ExtrasOption<GenericSQLStructure>>, ExtrasOption<GenericSQLStructure>>
+) {
+  return genericSelect(table, where, options, SelectResultMode.Numeric, 'sum');
 };
 
 /**
@@ -670,8 +724,14 @@ export const count: NumericAggregateSignatures = function (table, where, options
  * aggregated, or `all`
  * @param options Options object. Useful keys may be: `columns`, `alias`.
  */
-export const sum: NumericAggregateSignatures = function (table, where, options?) {
-  return select(table, where, options, SelectResultMode.Numeric, 'sum');
+export const sum: NumericAggregateSignatures<SQLStructure, SQLStructure> = genericSum;
+
+export const genericAvg = function (
+  table: GenericSQLStructure['Table'],
+  where: GenericSQLStructure['Whereable'] | SQLFragment | AllType,
+  options?: SelectOptionsForTable<any, GenericSQLStructure, ColumnsOption<GenericSQLStructure>, LateralOption<ColumnsOption<GenericSQLStructure>, ExtrasOption<GenericSQLStructure>>, ExtrasOption<GenericSQLStructure>>
+) {
+  return genericSelect(table, where, options, SelectResultMode.Numeric, 'avg');
 };
 
 /**
@@ -683,8 +743,14 @@ export const sum: NumericAggregateSignatures = function (table, where, options?)
  * aggregated, or `all`
  * @param options Options object. Useful keys may be: `columns`, `alias`.
  */
-export const avg: NumericAggregateSignatures = function (table, where, options?) {
-  return select(table, where, options, SelectResultMode.Numeric, 'avg');
+export const avg: NumericAggregateSignatures<SQLStructure, SQLStructure> = genericAvg;
+
+export const genericMin = function (
+  table: GenericSQLStructure['Table'],
+  where: GenericSQLStructure['Whereable'] | SQLFragment | AllType,
+  options?: SelectOptionsForTable<any, GenericSQLStructure, ColumnsOption<GenericSQLStructure>, LateralOption<ColumnsOption<GenericSQLStructure>, ExtrasOption<GenericSQLStructure>>, ExtrasOption<GenericSQLStructure>>
+) {
+  return genericSelect(table, where, options, SelectResultMode.Numeric, 'min');
 };
 
 /**
@@ -696,8 +762,14 @@ export const avg: NumericAggregateSignatures = function (table, where, options?)
  * aggregated, or `all`
  * @param options Options object. Useful keys may be: `columns`, `alias`.
  */
-export const min: NumericAggregateSignatures = function (table, where, options?) {
-  return select(table, where, options, SelectResultMode.Numeric, 'min');
+export const min: NumericAggregateSignatures<SQLStructure, SQLStructure> = genericMin;
+
+export const genericMax = function (
+  table: GenericSQLStructure['Table'],
+  where: GenericSQLStructure['Whereable'] | SQLFragment | AllType,
+  options?: SelectOptionsForTable<any, GenericSQLStructure, ColumnsOption<GenericSQLStructure>, LateralOption<ColumnsOption<GenericSQLStructure>, ExtrasOption<GenericSQLStructure>>, ExtrasOption<GenericSQLStructure>>
+) {
+  return genericSelect(table, where, options, SelectResultMode.Numeric, 'max');
 };
 
 /**
@@ -709,6 +781,169 @@ export const min: NumericAggregateSignatures = function (table, where, options?)
  * aggregated, or `all`
  * @param options Options object. Useful keys may be: `columns`, `alias`.
  */
-export const max: NumericAggregateSignatures = function (table, where, options?) {
-  return select(table, where, options, SelectResultMode.Numeric, 'max');
+export const max: NumericAggregateSignatures<SQLStructure, SQLStructure> = genericMax;
+
+
+/* === table, tables === */
+
+/*
+ * To allow partial type argument inference, split shortcuts into 2 chained
+ * functions. The first part (table) uses overridable type arguments and
+ * the second one (insert, select, ...) uses type arguments for inference.
+ * https://github.com/microsoft/TypeScript/issues/26242
+ */
+
+interface TableNumericAggregateSignatures <
+  S extends GenericSQLStructure,
+  O extends GenericSQLStructure
+  > {
+  <
+    C extends ColumnsOption<S>,
+    L extends LateralOption<C, E>,
+    E extends ExtrasOption<S>,
+    >(
+    where: S['Whereable'] | SQLFragment | AllType,
+    options?: SelectOptionsForTable<S, O, C, L, E>,
+  ): SQLFragment<number>;
+}
+
+interface TableReturn <
+  S extends GenericSQLStructure,
+  O extends GenericSQLStructure
+> {
+  insert<C extends ColumnsOption<S>, E extends ExtrasOption<S>>(
+    values: S['Insertable'],
+    options?: ReturningOptionsForTable<S, C, E>
+  ): SQLFragment<ReturningTypeForTable<S, C, E>>;
+
+  insert<C extends ColumnsOption<S>, E extends ExtrasOption<S>>(
+    values: S['Insertable'][],
+    options?: ReturningOptionsForTable<S, C, E>
+  ): SQLFragment<ReturningTypeForTable<S, C, E>[]>;
+
+  upsert<
+    C extends ColumnsOption<S>,
+    E extends ExtrasOption<S>,
+    UC extends UpdateColumns<S> | undefined,
+    RA extends UpsertReportAction | undefined
+    >(
+    values: S['Insertable'],
+    conflictTarget: UpsertConflictTargetForStructure<S>,
+    options?: UpsertOptions<S, C, E, UC, RA>
+  ): SQLFragment<UpsertReturnableForTable<S, C, E, RA> | (UC extends never[] ? undefined : never)>;
+
+  upsert<
+    C extends ColumnsOption<S>,
+    E extends ExtrasOption<S>,
+    UC extends UpdateColumns<S> | undefined,
+    RA extends UpsertReportAction | undefined
+    >(
+    values: S['Insertable'][],
+    conflictTarget: UpsertConflictTargetForStructure<S>,
+    options?: UpsertOptions<S, C, E, UC, RA>
+  ): SQLFragment<UpsertReturnableForTable<S, C, E, RA>[]>;
+
+  update<C extends ColumnsOption<S>, E extends ExtrasOption<S>>(
+    values: S['Updatable'],
+    where: S['Whereable'] | SQLFragment,
+    options?: ReturningOptionsForTable<S, C, E>
+  ): SQLFragment<ReturningTypeForTable<S, C, E>[]>;
+
+  deletes<C extends ColumnsOption<S>, E extends ExtrasOption<S>>(
+    where: S['Whereable'] | SQLFragment,
+    options?: ReturningOptionsForTable<S, C, E>
+  ): SQLFragment<ReturningTypeForTable<S, C, E>[]>;
+
+  truncate(): SQLFragment<undefined>;
+  truncate(optId: TruncateIdentityOpts): SQLFragment<undefined>;
+  truncate(optFK: TruncateForeignKeyOpts): SQLFragment<undefined>;
+  truncate(optId: TruncateIdentityOpts, optFK: TruncateForeignKeyOpts): SQLFragment<undefined>;
+
+  select<C extends ColumnsOption<S>,
+    L extends LateralOption<C, E>,
+    E extends ExtrasOption<S>,
+    M extends SelectResultMode = SelectResultMode.Many
+    >(
+    where: S['Whereable'] | SQLFragment | AllType,
+    options?: SelectOptionsForTable<S, O, C, L, E>,
+    mode?: M,
+    aggregate?: string,
+  ): SQLFragment<FullSelectReturnTypeForTable<S, C, L, E, M>>;
+
+  selectOne<
+    C extends ColumnsOption<S>,
+    L extends LateralOption<C, E>,
+    E extends ExtrasOption<S>,
+    >(
+    where: S['Whereable'] | SQLFragment | AllType,
+    options?: SelectOptionsForTable<S, O, C, L, E>,
+  ): SQLFragment<FullSelectReturnTypeForTable<S, C, L, E, SelectResultMode.One>>;
+
+  selectExactlyOne<
+    C extends ColumnsOption<S>,
+    L extends LateralOption<C, E>,
+    E extends ExtrasOption<S>,
+    >(
+    where: S['Whereable'] | SQLFragment | AllType,
+    options?: SelectOptionsForTable<S, O, C, L, E>,
+  ): SQLFragment<FullSelectReturnTypeForTable<S, C, L, E, SelectResultMode.ExactlyOne>>;
+
+  count: TableNumericAggregateSignatures<S, O>;
+  sum: TableNumericAggregateSignatures<S, O>;
+  avg: TableNumericAggregateSignatures<S, O>;
+  max: TableNumericAggregateSignatures<S, O>;
+  min: TableNumericAggregateSignatures<S, O>;
+}
+
+interface TableSignatures {
+  <
+    S extends GenericSQLStructure = SQLStructure,
+    O extends GenericSQLStructure = SQLStructure
+    >(tables: S['Table']
+  ): TableReturn<S, O>;
+}
+
+/**
+ * Creates a query generator for the specified table. Allows manual override of
+ * type arguments.
+ * @param table The table to query
+ */
+export const table: TableSignatures = <S extends GenericSQLStructure>(table: S['Table']): TableReturn<S, GenericSQLStructure> => {
+  return {
+    insert: genericInsert.bind(undefined, table),
+    upsert: genericUpsert.bind(undefined, table),
+    update: genericUpdate.bind(undefined, table),
+    deletes: genericDeletes.bind(undefined, table),
+    truncate: genericTruncate.bind(undefined, table),
+    select: genericSelect.bind(undefined, table),
+    selectOne: genericSelectOne.bind(undefined, table),
+    selectExactlyOne: genericSelectExactlyOne.bind(undefined, table),
+    count: genericCount.bind(undefined, table),
+    sum: genericSum.bind(undefined, table),
+    avg: genericAvg.bind(undefined, table),
+    min: genericMin.bind(undefined, table),
+    max: genericMax.bind(undefined, table)
+  };
+};
+
+interface TablesReturn {
+  truncate(): SQLFragment<undefined>;
+  truncate(optId: TruncateIdentityOpts): SQLFragment<undefined>;
+  truncate(optFK: TruncateForeignKeyOpts): SQLFragment<undefined>;
+  truncate(optId: TruncateIdentityOpts, optFK: TruncateForeignKeyOpts): SQLFragment<undefined>;
+}
+
+interface TablesSignatures {
+  <S extends GenericSQLStructure = SQLStructure>(tables: S['Table'][]): TablesReturn;
+}
+
+/**
+ * Creates a query generator for the specified tables. Allows manual override of
+ * type arguments.
+ * @param tables The tables to query
+ */
+export const tables: TablesSignatures = (tables: GenericSQLStructure['Table'][]): TablesReturn => {
+  return {
+    truncate: genericTruncate.bind(undefined, tables)
+  };
 };
diff --git a/src/generate/config.ts b/src/generate/config.ts
index af000db..612d274 100644
--- a/src/generate/config.ts
+++ b/src/generate/config.ts
@@ -23,6 +23,11 @@ export interface OptionalConfig {
   customTypesTransform: 'PgMy_type' | 'my_type' | 'PgMyType' | ((s: string) => string);
   columnOptions: ColumnOptions;
   schemaJSDoc: boolean;
+  /**
+   * Prefix to apply to the table or a function to create the name from the
+   * table
+   */
+  globalStructureName: string | ((table: string) => string);
 }
 
 interface SchemaRules {
@@ -46,7 +51,7 @@ export type CompleteConfig = RequiredConfig & OptionalConfig;
 
 const defaultConfig: OptionalConfig = {
   outDir: '.',
-  outExt: '.d.ts',
+  outExt: '.ts',
   schemas: { public: { include: '*', exclude: [] } },
   debugListener: false,
   progressListener: false,
@@ -54,6 +59,7 @@ const defaultConfig: OptionalConfig = {
   customTypesTransform: 'PgMy_type',
   columnOptions: {},
   schemaJSDoc: true,
+  globalStructureName: (table: string) => table
 };
 
 export const moduleRoot = () => {
diff --git a/src/generate/tables.ts b/src/generate/tables.ts
index b7de61d..212a82a 100644
--- a/src/generate/tables.ts
+++ b/src/generate/tables.ts
@@ -155,6 +155,10 @@ export const definitionForRelationInSchema = async (
     if (isUpdatable) updatables.push(`${columnDoc}${column}?: ${updatableTypes} | db.SQLFragment<any, ${updatableTypes}>;`);
   });
 
+  const globalStructureName = typeof config.globalStructureName === 'function'
+    ? config.globalStructureName(rel.name)
+    : `${config.globalStructureName}${rel.name}`;
+
   const
     result = await queryFn({
       text: `
@@ -182,30 +186,35 @@ export const definitionForRelationInSchema = async (
  * - ${friendlyRelType} in database
  */` : ``,
     tableDef = `${tableComment}
-export namespace ${rel.name} {
-  export type Table = '${rel.name}';
-  export interface Selectable {
+export interface ${rel.name} {
+  Schema: '${schemaName}';
+  Table: '${rel.name}';
+  Selectable: {
     ${selectables.join('\n    ')}
-  }
-  export interface JSONSelectable {
+  };
+  JSONSelectable: {
     ${JSONSelectables.join('\n    ')}
-  }
-  export interface Whereable {
+  };
+  Whereable: {
     ${whereables.join('\n    ')}
-  }
-  export interface Insertable {
+  };
+  Insertable: {
     ${insertables.length > 0 ? insertables.join('\n    ') : `[key: string]: never;`}
-  }
-  export interface Updatable {
+  };
+  Updatable: {
     ${updatables.length > 0 ? updatables.join('\n    ') : `[key: string]: never;`}
+  };
+  UniqueIndex: ${uniqueIndexes.length > 0
+    ? uniqueIndexes.map(ui => "'" + ui.indexname + "'").join(' | ')
+    : 'never'};
+}
+
+declare global {
+  namespace Zapatos {
+    interface StructureMap {
+      ${globalStructureName}: ${rel.name};
+    }
   }
-  export type UniqueIndex = ${uniqueIndexes.length > 0 ?
-        uniqueIndexes.map(ui => "'" + ui.indexname + "'").join(' | ') :
-        'never'};
-  export type Column = keyof Selectable;
-  export type OnlyCols<T extends readonly Column[]> = Pick<Selectable, T[number]>;
-  export type SQLExpression = db.GenericSQLExpression | db.ColumnNames<Updatable | (keyof Updatable)[]> | db.ColumnValues<Updatable> | Table | Whereable | Column;
-  export type SQL = SQLExpression | SQLExpression[];
 }`;
   return tableDef;
 };
@@ -228,25 +237,19 @@ const mappedUnion = (arr: Relation[], fn: (name: string) => string) =>
 export const crossTableTypesForTables = (relations: Relation[]) => `${relations.length === 0 ?
   '\n// `never` rather than `any` types would be more accurate in this no-tables case, but they stop `shortcuts.ts` compiling\n' : ''
   }
-export type Table = ${mappedUnion(relations, name => `${name}.Table`)};
-export type Selectable = ${mappedUnion(relations, name => `${name}.Selectable`)};
-export type JSONSelectable = ${mappedUnion(relations, name => `${name}.JSONSelectable`)};
-export type Whereable = ${mappedUnion(relations, name => `${name}.Whereable`)};
-export type Insertable = ${mappedUnion(relations, name => `${name}.Insertable`)};
-export type Updatable = ${mappedUnion(relations, name => `${name}.Updatable`)};
-export type UniqueIndex = ${mappedUnion(relations, name => `${name}.UniqueIndex`)};
-export type Column = ${mappedUnion(relations, name => `${name}.Column`)};
-export type AllBaseTables = [${relations.filter(rel => rel.type === 'table').map(rel => `${rel.name}.Table`).join(', ')}];
-export type AllForeignTables = [${relations.filter(rel => rel.type === 'fdw').map(rel => `${rel.name}.Table`).join(', ')}];
-export type AllViews = [${relations.filter(rel => rel.type === 'view').map(rel => `${rel.name}.Table`).join(', ')}];
-export type AllMaterializedViews = [${relations.filter(rel => rel.type === 'mview').map(rel => `${rel.name}.Table`).join(', ')}];
-export type AllTablesAndViews = [${relations.map(rel => `${rel.name}.Table`).join(', ')}];
-
-${['Selectable', 'JSONSelectable', 'Whereable', 'Insertable', 'Updatable', 'UniqueIndex', 'Column', 'SQL'].map(thingable => `
-export type ${thingable}ForTable<T extends Table> = ${relations.length === 0 ? 'any' : `{${relations.map(rel => `
-  ${rel.name}: ${rel.name}.${thingable};`).join('')}
-}[T]`};
-`).join('')}`;
+export type Table = ${mappedUnion(relations, name => `${name}['Table']`)};
+export type Selectable = ${mappedUnion(relations, name => `${name}['Selectable']`)};
+export type JSONSelectable = ${mappedUnion(relations, name => `${name}['JSONSelectable']`)};
+export type Whereable = ${mappedUnion(relations, name => `${name}['Whereable']`)};
+export type Insertable = ${mappedUnion(relations, name => `${name}['Insertable']`)};
+export type Updatable = ${mappedUnion(relations, name => `${name}['Updatable']`)};
+export type UniqueIndex = ${mappedUnion(relations, name => `${name}['UniqueIndex']`)};
+export type Column = ${mappedUnion(relations, name => `db.Column<${name}>`)};
+export type AllBaseTables = [${relations.filter(rel => rel.type === 'table').map(rel => `${rel.name}['Table']`).join(', ')}];
+export type AllForeignTables = [${relations.filter(rel => rel.type === 'fdw').map(rel => `${rel.name}['Table']`).join(', ')}];
+export type AllViews = [${relations.filter(rel => rel.type === 'view').map(rel => `${rel.name}['Table']`).join(', ')}];
+export type AllMaterializedViews = [${relations.filter(rel => rel.type === 'mview').map(rel => `${rel.name}['Table']`).join(', ')}];
+export type AllTablesAndViews = [${relations.map(rel => `${rel.name}['Table']`).join(', ')}];`;
 
 
 const createColumnDoc = (schemaName: string, rel: Relation, columnDetails: Record<string, unknown>) => {
diff --git a/src/generate/tsOutput.ts b/src/generate/tsOutput.ts
index 87e3f11..e895c71 100644
--- a/src/generate/tsOutput.ts
+++ b/src/generate/tsOutput.ts
@@ -30,6 +30,10 @@ ${declarations.replace(/^(?=[ \t]*\S)/gm, '  ')}
 }
 `;
 
+const outputBody = (declarations: string) => `
+${declarations.replace(/^(?=[ \t]*\S)/gm, '')}
+`;
+
 const customTypeHeader = `/*
 ** Please edit this file as needed **
 It's been generated by Zapatos as a custom type definition placeholder, and won't be overwritten
@@ -88,7 +92,7 @@ export const tsForConfig = async (config: CompleteConfig, debug: (s: string) =>
     schemaTables = schemaData.map(r => r.tables),
     allTables = ([] as Relation[]).concat(...schemaTables).sort((a, b) => a.name.localeCompare(b.name)),
     hasCustomTypes = Object.keys(customTypes).length > 0,
-    ts = header() + declareModule('zapatos/schema',
+    ts = header() + outputBody(
       `\nimport type * as db from 'zapatos/db';\n` +
       (hasCustomTypes ? `import type * as c from 'zapatos/custom';\n` : ``) +
       versionCanary +
diff --git a/src/typings/zapatos/schema.ts b/src/typings/zapatos/schema.ts
deleted file mode 100644
index b578d49..0000000
--- a/src/typings/zapatos/schema.ts
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
-Zapatos: https://jawj.github.io/zapatos/
-Copyright (C) 2020 - 2021 George MacKerron
-Released under the MIT licence: see LICENCE file
-*/
-
-// this file exists only to suppress type errors when compiling the files in src/db
-
-/* eslint-disable @typescript-eslint/no-unused-vars */
-export interface Updatable { [k: string]: any }
-export interface Whereable { [k: string]: any }
-export interface Insertable { [k: string]: any }
-export type Table = string;
-export type Column = string;
-export type JSONSelectableForTable<T extends Table> = { [k: string]: any };
-export type SelectableForTable<T extends Table> = { [k: string]: any };
-export type WhereableForTable<T extends Table> = { [k: string]: any };
-export type InsertableForTable<T extends Table> = { [k: string]: any };
-export type UpdatableForTable<T extends Table> = { [k: string]: any };
-export type ColumnForTable<T extends Table> = string;
-export type UniqueIndexForTable<T extends Table> = string;
-export type SQLForTable<T extends Table> = any;
diff --git a/tsconfig.json b/tsconfig.json
index 1d6fcb2..c3db422 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -10,11 +10,6 @@
     "module": "CommonJS",
     "strict": true,
     "declaration": true,
-    "noUnusedLocals": true,
-    "paths": {
-      "*": [
-        "src/typings/*"
-      ]
-    }
+    "noUnusedLocals": true
   },
-}
\ No newline at end of file
+}