1. guides
prorm
  • prorm documentation
  • Known test gaps
  • Architecture
  • Core concepts
  • Database types & coverage
  • Getting started
  • Going further
  • compliance
    • Compliance
    • The security toolkit: `prorm audit`
    • Checklists by regulation
    • Declaring personal data
    • Evidence bundles
    • Evidence
    • Frameworks: `@Security`
    • Jurisdictions
    • Platform policies
    • Protecting data
    • The regulation dataset
    • Residency and cross-border transfers
    • Retention & integrity
    • Status
    • Subject rights
  • decorators
    • prorm with decorators
    • Models with decorators
    • Querying a decorated model
    • Relations with decorators
  • diagrams
    • Diagram generators
    • Chen diagram
    • Class diagram
    • Dependency diagram
    • ER diagram
    • Flow diagram
    • From your models to a diagram
    • Gantt diagram
    • Index diagram
    • Migration diagram
    • Model diagram
    • Package diagram
    • Crow’s-foot diagram
    • Schema documentation
    • Sequence diagram
    • State diagram
    • Tree diagram
  • dialects
    • SQL dialects
    • AlloyDB Dialect
    • AlloyDB Omni Dialect
    • Amazon Athena Dialect
    • Aurora DSQL Dialect
    • Amazon Aurora MySQL Dialect
    • Amazon Aurora PostgreSQL Dialect
    • Azure Database for MySQL Dialect
    • Azure Database for PostgreSQL Dialect
    • Azure SQL Database Dialect
    • Azure SQL Managed Instance Dialect
    • Google BigQuery Dialect
    • Citus Dialect
    • ClickHouse dialect
    • Cloud Authentication (`cloud-auth`)
    • Cloud SQL for SQL Server Dialect
    • Cloud SQL for MySQL Dialect
    • Cloud SQL for PostgreSQL Dialect
    • CockroachDB Dialect
    • Azure Cosmos DB for PostgreSQL Dialect
    • CrateDB Dialect
    • Cloudflare D1 Dialect
    • Databricks dialect
    • IBM Db2 Dialect
    • Dolt Dialect
    • Apache Doris Dialect
    • Druid Dialect
    • DuckDB Dialect
    • Exasol dialect
    • Microsoft Fabric Data Warehouse Dialect
    • Firebird Dialect
    • Greenplum Dialect
    • SAP HANA Dialect
    • MySQL HeatWave Dialect
    • Azure Data Explorer (Kusto) Dialect — T-SQL
    • MariaDB Dialect
    • Materialize Dialect
    • MonetDB Dialect
    • MotherDuck Dialect
    • Microsoft SQL Server Dialect
    • MySQL Dialect
    • Neon Dialect
    • OceanBase Dialect
    • openGauss Dialect
    • Oracle Dialect
    • Oracle Autonomous Database Dialect
    • ParadeDB Dialect
    • PolarDB Dialect
    • PostgreSQL Dialect
    • Presto Dialect
    • QuestDB Dialect
    • Aurora RDS Data API Dialect (`rdsdata`)
    • Amazon RDS for Db2 Dialect
    • Amazon RDS for MariaDB Dialect
    • Amazon RDS for SQL Server Dialect
    • Amazon RDS for MySQL Dialect
    • Amazon RDS for Oracle Dialect
    • Amazon RDS for PostgreSQL Dialect
    • Amazon Redshift
    • Amazon Redshift Data API Dialect
    • RisingWave Dialect
    • rqlite Dialect
    • SingleStore Dialect
    • Snowflake Dialect
    • Google Cloud Spanner Dialect
    • Spanner (PostgreSQL interface) Dialect
    • SQLite Dialect
    • StarRocks Dialect
    • Supabase Dialect
    • Azure Synapse Analytics (dedicated SQL pool)
    • Teradata Dialect
    • TiDB Dialect
    • TimescaleDB Dialect
    • Trino Dialect
    • Turso / libSQL Dialect
    • Vertica dialect
    • Vitess Dialect
    • Yellowbrick Dialect
    • YugabyteDB Dialect
  • guides
    • Access rules and behaviour profiles
    • ArangoDB (AQL)
    • Associations
    • Audit levels and escalation
    • Audit logging
    • In the browser
    • Bulk operations
    • Caching
    • Capabilities, tiers and team roles
    • CLI
    • Cloudflare
    • Compliance & data protection
    • Connection Pooling & Performance
    • Security in the console
    • Couchbase: structured N1QL queries
    • Data types
    • Decorators
    • Eager loading
    • Enums and constants
    • Error handling & error types
    • Extensions
    • External fields
    • Foreign data wrappers
    • Graph databases
    • Hooks & lifecycle events
    • Indexes & constraints
    • InfluxDB: structured Flux pipelines
    • klock-errors
    • klock — the `.klock` file
    • Local databases (`prorm db up`)
    • Structured log search — Splunk, Graylog, Papertrail, Sumo Logic
    • Logging
    • Grafana Loki: structured LogQL queries
    • MCP server
    • Migrate — the data transfer subsystem
    • Migrations & Schema Sync
    • Models from an existing database
    • Defining models
    • Multiple databases
    • OrientDB, Neptune and TigerGraph
    • Passwords
    • Importing a Prisma schema
    • Structured PromQL and MetricsQL
    • Query firewall
    • QueryInterface
    • Query operators reference
    • Query optimization
    • Composing find options with `pipe()` and `Q`
    • Query safety: the fail-closed WHERE guard
    • Querying
    • Raw Queries & Query Building
    • Read replicas
    • Schema diffing & migration generation
    • Views, triggers & other schema objects
    • Scopes & default scopes
    • Seeders
    • SPARQL / RDF triplestores
    • SQL constants
    • SQL features
    • SQL function builders
    • SQLite advanced features
    • StoreKey — a prod-orm database as the storage
    • Streaming results
    • Terraform
    • Transactions & Isolation Levels
    • Type mapping: legacy and modern
    • TypeScript types
    • Database users, roles & privileges
    • Validation & constraints
    • Virtual & Computed Fields
    • Writing docs
  • javascript
    • prorm in JavaScript
    • Models in JavaScript
    • Querying in JavaScript
    • Relations in JavaScript
  • runbooks
    • Operational runbooks
    • Connection failures
    • Credential rotation
    • Failover
    • Incident checklist
    • Deploying klock v2
    • Migration rollback
  • running-databases
    • Running databases in Docker
    • Running prorm under Bun in Docker
    • Running Cassandra in Docker with prorm
    • Running ClickHouse in Docker with prorm
    • Running CockroachDB in Docker with prorm
    • Running prorm under Deno in Docker
    • Running Elasticsearch in Docker with prorm
    • Running MariaDB in Docker with prorm
    • Running MongoDB in Docker with prorm
  • prorm control plane
    • Introduction
    • Authentication
    • Errors
    • Getting started
      • Service
        • Is it up
        • This description
    • Account
      • Sign-up and verification
        • Create an account
        • Exchange credentials for a token
        • Verify with the emailed code
        • Verify by clicking the emailed link
        • Name the parent or guardian
        • What a consent link is about
        • Give consent for a child's account
        • Ask the parent or guardian again
        • Send a new code and link
      • Family
        • Everyone this account is responsible for
        • One child, in detail
        • Turn a limit on or off
      • Profile
        • Who am I
        • Change the account
        • Every address on the account
        • Add an address
        • Confirm an address with the code mailed to it
        • Mail a fresh code to an unconfirmed address
        • Make an address primary
        • Remove an address
        • What this caller may do
    • Security
      • Sessions
        • Everywhere this account is signed in
        • Sign out everywhere else
        • Sign one out
        • A token for the CLI on a named machine
        • A token for the customer console, from the staff one
        • Park a sign-in for the CLI to collect
        • The CLI collecting its sign-in
        • The team's members' live sessions
        • Sign a member's session out
        • Sign an account out everywhere
        • Everywhere the account is signed in
        • Sign an account's session out
      • Single sign-on
        • Begin a single sign-on
        • The provider's return
        • Link the signed-in account to a team's provider
        • Which team an address signs in to
        • The team's single sign-on, as a member sees it
        • Set the team's OpenID Connect provider up, or change it
        • Remove the provider
        • The team's domain claims and the DNS record each needs
        • Prove a claimed domain
      • MFA and passwords
        • Start enrolling a second factor
        • Prove the app has it
        • Remove the second factor
        • Ask for a reset link
        • Set a new password with the emailed token
      • Klock
        • Open a device-bound klock session
        • Check in, for the next grant
        • Step up the session asking
        • Rotate the device key
        • Freeze a session
        • Unfreeze a session
        • A guest grant
        • The revocation feed
        • The published keyset
        • What this control plane supports
      • Devices
        • Your devices, or a team's
        • Approve a new device's pairing code
        • One device
        • Rename a device
        • Revoke a device
        • Suspend a device
        • Reinstate a suspended device
        • Wipe a device
        • Ask a device to rotate its key
        • The team's members' devices
        • Revoke a member's device
        • An account's devices
        • Revoke an account's device
        • Wipe an account's device
        • The device fleet
      • Access rules and behaviour
        • The access rules that bear on you
        • Add an access rule
        • This request, as the rules see it
        • One access rule
        • Remove an access rule
        • The behaviour profiles that bear on you
        • Add or change a behaviour profile
        • The profile presets
        • Your behaviour findings
        • Acknowledge a finding
        • One behaviour profile
        • Remove a behaviour profile
        • The team's access rules
        • Add a team access rule
        • Remove a team access rule
        • The team's behaviour profiles
        • Add or change a team behaviour profile
        • Remove a team behaviour profile
        • What the team's profiles caught
        • Acknowledge a team finding
      • Recovery and lockdown
        • Ask for a recovery link
        • Recover access with the emailed code
        • Is the account locked down
        • Lock the account down
        • Release a lockdown
        • Lock a member down
        • Release a member's lockdown
      • MCP tokens
        • Make a delegated token for one MCP client
        • The account's delegated tokens
        • Revoke a delegated token
        • What a delegated token may do now
        • Run one MCP tool with a delegated token
        • Run a device-signed MCP tool call relayed by the MCP Worker
      • Kerberos
        • Give the team its own Kerberos realm
        • The team's realm
        • Remove the team's realm
    • Logging and monitoring
      • Audit log
        • What has been done to the account
        • What has happened to this account
        • The account's audit trail
      • Operations
        • Everything that has been asked of this database
        • One, with its steps
        • Stop it
        • Put a failed one back in the queue
        • Every operation, across all accounts
      • Metrics and events
        • Every measurement, for a graph
        • Who did what to it
    • Billing
      • Plans and pricing
        • What the plans allow
        • The rate card
        • What one database would cost
        • What this account is paying for, itemised
      • Subscriptions and invoices
        • What this month's invoice will say
        • What this account is on
        • What it has been charged
        • Start a Stripe Checkout session
        • Open the customer portal
        • Stripe's events
        • Buy more connection pools
      • Team billing
        • The team's billing account
        • What the team has been charged
        • What this month's invoice will say
        • The team's cards
        • Add a card, through a Stripe-hosted setup session
        • Make a card the team's default
        • Remove a card
        • Start the team paying
        • Open the Stripe portal on the team's customer
        • Change the team's plan
        • Who receives the team's bills
        • How the team pays for transfers
    • Support
      • Support chat
        • My conversations
        • Start a conversation
        • Every support conversation, open first
        • A ticket for the socket
        • One conversation, with who is in it and who is connected
        • Rename a group; open or close a support conversation
        • The lines, oldest first
        • Say something
        • Add somebody
        • Mark read
    • Administration
      • Users
        • Every account
        • One account, with everything hanging off it
        • Grant or revoke admin
        • Verify an account by hand
        • Lock or unlock sign-in
        • Allow or hold provisioning
        • Send the verification mail again
        • Set the plan by hand
      • Platform
        • Every database and store, across all accounts
        • The counts worth putting on a dashboard
      • Staff and permissions
        • What kind of admin the caller is, and which scopes they hold
        • The admin presets
        • Every admin, and the scopes each resolves to
        • Make an account an admin of a kind
        • Change an admin's kind, or a custom admin's scopes
        • Revoke admin
      • Team administration
        • Every team, with its owner and size
        • One team in full — members with their accounts, and projects
        • Hand the team to another member
        • Put an account in the team, active at once
        • Change a member's role
        • Remove a member
      • Assumed identities
        • Assume an identity — act as a customer account
        • The identities the caller holds open
        • End an assumed identity
      • Support inbox
        • The platform's addresses
        • Add a platform address
        • One address, with its counts
        • Change an address's label, routing, or whether it accepts mail
        • Remove an address that holds no mail
        • Make, adopt or repair the address's routing rule
        • Every admin's personal address, made where missing
        • File a raw message, as if it had arrived
        • The inbox
        • One message, whole
        • Mark a message
        • Hand a message to an admin, or take it back
        • Leave an internal note
        • Reply, from the address the message came to
        • What is waiting
    • Databases
      • Databases
        • Data stores
          • Every data store on the account
          • Provision a data store
          • Change a data store that is already running
          • One data store
          • Deprovision it
          • Report what it is using
          • How to reach a data store
        • Connections and credentials
          • The api keys on a database
          • Issue a key
          • Revoke a key
          • The engine users we created
          • Create a user inside the database
          • Give a user a new password
          • Drop a user
          • How the database is reached
          • Set how it is reached
          • Revoke every api key on it
          • How to connect to it
          • The ssh keys that open its bastion
          • Add a key, or have one made
          • The private half of a generated key, once
          • Revoke an ssh key
        • Schema and objects
          • The SQL objects we put in it
          • Create one, and apply it
          • What is in the database, as the engine reports it
          • One table
          • What it would run, without running it
          • Redefine an object in place
          • Drop it
          • The extensions installed in it
        • Migrations
          • A plan compiled to statements, recording nothing
          • The migrations recorded for it
          • Record one
          • Apply everything recorded and not yet run
          • Apply everything pending, oldest version first
        • Lifecycle
          • Grow or shrink it
          • Stop it accepting connections
          • Start it again
          • Move it to another region
        • Backups and replicas
          • Take a backup
          • The backups it has
          • Restore one into it
          • What has been restored into it, and from where
          • Its read copies
          • Add one
        • Policies
          • The catalog
          • One policy
          • What this database is held to
          • Switch a policy on, or change its knobs
          • Switch it off
          • Mark the policies reviewed
          • Evaluate the periodic policies now
          • Who is behind a credential
        • Passwordless
          • The database's passwordless sessions
          • Issue a passwordless session (v1)
          • Revoke a passwordless session
          • Bind a session to a device key
          • Issue a v2 session for a host to bind
          • Redeem an enrolment ticket on the host
          • Check a passwordless credential
          • Run one described query under a passwordless credential
        • Database roles
          • The database's roles
          • Define a role
          • One role
          • Change what a role permits
          • Delete a role, and revoke every key granted it
          • Grant a role, which mints a key
          • Who holds a role
          • The api keys bound to a role
        • Pools
          • A database's connection pools, and how busy each is
          • Open another pool
          • Rename a pool or change its size
          • Close a pool
        • Data plane
          • Run a query against a database
          • Several statements, in order, over one connection
          • Is this database answering
          • What the proxy itself is holding
        • Transfers
          • The strategies this account's tier may use
          • Price a transfer without creating it
          • The account's transfer jobs, newest first
          • Create a transfer job
          • One job, and whether its certificate holds
          • Cancel an unfinished job
          • Start a created job, confirming its price
          • Report a job's status (the runner, or the owner's side of a local run)
        • Every database on the account
        • Provision a database
        • Change a database that is already running
        • One database
        • Deprovision it
        • Read or write it
        • Report what it is using
        • The engines this API will provision
        • Where a managed database can be put
    • Teams
      • Teams
        • Members
          • Who is on it
          • Invite somebody
          • Accept an invitation
          • Change somebody's role
          • Remove somebody
        • Projects
          • The projects a team runs
          • Start one
          • Rename a project, or move its environment
          • Delete a project
          • One project, and what is in it
          • Put a database or store in it
          • What is in a project
          • Take one out
        • The teams this account is on
        • Start one
        • The twelve roles, and what each may do
        • Rename a team
        • Close a team
        • One team
        • Hand the team to somebody else
        • Leave a team
    • Schemas
      • Error
      • ValidationErrors
      • Token
      • PolicyCategory
      • PolicySeverity
      • PolicyAction
      • PolicyTrigger
      • PolicyParam
      • Policy
      • PolicyCatalog
      • PolicyAssignment
      • PolicyOutcome
      • PolicyFiring
      • CredentialTrace
      • Relation
      • Restrictions
      • ChildSummary
      • SignupRequest
      • SigninRequest
      • UpdateMeRequest
      • User
      • Address
      • GeoPoint
      • D1Region
      • Usage
      • UsageReport
      • Resource
      • Database
      • DataStore
      • NewDatabase
      • NewDataStore
      • QueryRequest
      • DatabasePrivilege
      • ApiKey
      • DbUser
      • Access
      • AccessRequest
      • DatabaseObject
      • NewDatabaseObject
      • NewMigration
      • SchemaOperation
      • Migration
      • Operation
      • Session
      • AdminPowers
      • Admin
      • AuditEntry
      • TeamRole
      • Conversation
      • ChatMessage
      • TeamSso
      • Team
      • TeamMember
      • SshKey
      • ConnectionInfo
      • InboxAddress
      • InboxMailbox
      • InboxMessageSummary
      • InboxMessage
      • InboxNote
      • Page
      • Quote
      • Plan
      • ApiError
      • CapabilityRefusal
      • KlockErrorCode
      • PageWindow
      • SessionView
      • KlockStepUpRequest
      • KlockOpenRequest
      • KlockOpenedSession
      • UpdateMeResult
      • CapabilitiesView
      • SessionLimits
      • Device
      • DeviceListed
      • DeviceTeamRef
      • DeviceCommand
      • DeviceAuditLine
      • DeviceActionRequest
      • StaffActionRequest
      • ManagedSession
      • SessionRevoked
      • AccessRule
      • AccessRuleRequest
      • BehaviourProfile
      • BehaviourProfileRequest
      • BehaviourProfileSaved
      • BehaviourFinding
      • BehaviourFindingAck
      • StepUpProof
      • Removed
      • MemberLockdownRequest
      • McpClient
      • McpDelegatedView
      • McpToolCall
      • McpForwardRequest
      • PasswordlessScope
      • RoleScope
      • PasswordlessSession
      • PasswordlessTlsMaterial
      • PasswordlessKerberosMaterial
      • ServiceDeviceKeys
      • ServiceSession
      • DatabaseRole
      • TransferEndpoint
      • TransferJobRequest
      • TransferQuote
      • TransferStrategy
      • TransferJob
      • TransferJobAccess
      • Pool
      • PoolAllowance
      • BillingSubscription
      • Invoice
      • BillingContact
      • PaymentMethod
      • UpcomingCharges
      • TeamBilling
      • TeamKerberosRealm
      • TeamSsoDomain
      • TeamSsoResponse
      • StoreConnection
      • BatchFailure
      • ProxyStatus
  1. guides

SQL features

The dialects expose a large amount of engine-specific SQL that the model layer
does not surface: generated columns, exclusion constraints, index hints,
sampling, cursors and table storage settings. This page is the index to it.
Every snippet below is the helper's real output, produced by calling it.
Most of these are emitted for you when you declare the equivalent option on a
model or index; you reach for the builder directly when writing a migration or
generating DDL yourself.
The builders return a clause, not a statement. You splice it into DDL or a
query that you write yourself, as the example below shows.
[!WARNING]
Support varies by engine, and most of these builders do not check their
input. Passing 'INITIALLY_DEFERRED' where the type says 'INITIALLY DEFERRED'
emits DEFERRABLE INITIALLY_DEFERRED rather than raising, so the value only
fails when the database sees it. Take the accepted values below literally.
Several of them also interpolate names without quoting (see the table at the
end), so pass only names you control.

A migration built from the builders#

Here is a room-booking table on PostgreSQL. It has an identity key, a stored
total, and a constraint that makes double-booking a room impossible:
import {
  buildIdentitySQL,
  buildGeneratedAlwaysSQL,
  buildExclusionSQL,
  generateReplicaIdentitySQL,
} from 'ts-prorm-orm';

export async function up(prorm: { query(sql: string): Promise<unknown> }) {
  await prorm.query('CREATE EXTENSION IF NOT EXISTS btree_gist'); // `room WITH =` in a GiST index
  await prorm.query(
    [
      'CREATE TABLE bookings (',
      `  id bigint ${buildIdentitySQL({ type: 'ALWAYS' })} PRIMARY KEY,`,
      '  room int NOT NULL,',
      '  during tstzrange NOT NULL,',
      '  nightly_rate numeric(10,2) NOT NULL,',
      '  nights int NOT NULL,',
      `  total numeric(12,2) ${buildGeneratedAlwaysSQL({ as: 'nightly_rate * nights', stored: true })},`,
      `  ${buildExclusionSQL('bookings', {
        name: 'no_overlap',
        using: 'gist',
        elements: ['room WITH =', 'during WITH &&'],
      })}`,
      ')',
    ].join('\n'),
  );
  await prorm.query(`ALTER TABLE bookings ${generateReplicaIdentitySQL({ type: 'FULL' })}`);
}

Columns#

Generated columns#

A column computed from others, maintained by the database.
import { buildGeneratedAlwaysSQL } from 'ts-prorm-orm';

buildGeneratedAlwaysSQL({ as: 'price * qty', stored: true });
// GENERATED ALWAYS AS (price * qty) STORED
stored: false gives a virtual column, recomputed on read. MySQL supports
both; PostgreSQL supports stored only.
A string as is raw SQL, passed through as written. For a portable expression,
pass fn() and col() together with a dialect instance, and the
identifiers are quoted for that engine:
import { buildGeneratedAlwaysSQL, fn, col } from 'ts-prorm-orm';

const dialect = prorm.getDialectInstance()!;
// `{ ...fn() }`: see the note below on the `as` type
buildGeneratedAlwaysSQL({ as: { ...fn('LOWER', col('email')) }, stored: true }, dialect);
[!NOTE]
A dialect name is not enough for the structured form:
buildGeneratedAlwaysSQL({ as: fn(…) }, 'postgres') throws
dialect.escapeId is not a function. Pass prorm.getDialectInstance().
The as option is typed as an object with an index signature, which the
FnExpression and OpExpression interfaces do not satisfy, so passing
fn(…) directly is a TypeScript error even though it works at runtime.
Spreading it into an object literal satisfies the type.
On a model, @Generated({ as: op('*', col('unitPrice'), col('quantity')) })
declares a computed column from an expression, and sync() compiles it for
the connected engine.

Identity columns#

The standard-SQL replacement for SERIAL / AUTO_INCREMENT.
import { buildIdentitySQL } from 'ts-prorm-orm';

buildIdentitySQL({ type: 'ALWAYS', start: 1, increment: 1 });
// GENERATED ALWAYS AS IDENTITY ( START WITH 1 INCREMENT BY 1 )

buildIdentitySQL({ type: 'BY DEFAULT', start: 1000 });
// GENERATED BY DEFAULT AS IDENTITY ( START WITH 1000 )
type is 'ALWAYS' or 'BY DEFAULT'. ALWAYS refuses an explicit insert into
the column, which is usually what you want: it stops an application from
writing an id that the sequence will later reissue. BY DEFAULT is the one to
use while importing rows that already have ids.

Collation#

import { generateColumnCollateSQL } from 'ts-prorm-orm';

generateColumnCollateSQL('name', 'en_US.utf8');
// MODIFY name VARCHAR(255) CHARACTER SET utf8mb4 COLLATE en_US.utf8
This is MySQL ALTER TABLE … MODIFY syntax, and it always declares the column
as VARCHAR(255), so it would shorten a longer column. Collation decides sort
order and comparison. A column compared against another of a different
collation is an error on some engines and a silent full scan on others.

Constraints#

Exclusion constraints#

PostgreSQL's generalisation of UNIQUE: no two rows may satisfy the given
operator pairwise. The canonical use is preventing overlapping reservations,
which a unique constraint cannot express.
import { buildExclusionSQL } from 'ts-prorm-orm';

buildExclusionSQL('bookings', {
  name: 'no_overlap',
  using: 'gist',
  elements: ['room WITH =', 'during WITH &&'],
});
// CONSTRAINT "no_overlap" EXCLUDE USING gist (room WITH =, during WITH &&)
String elements pass through unchanged. Structured elements
({ expr, operator, opclass }) and a where are compiled, with the operator
checked against ExclusionOperator. Without a name, the constraint is named
excl_<table>_<timestamp>, which differs on every run, so always pass one in a
migration.

Deferrable constraints#

import { buildDeferrableSQL } from 'ts-prorm-orm';

buildDeferrableSQL({ deferrable: 'INITIALLY DEFERRED' });
// DEFERRABLE INITIALLY DEFERRED
Accepted: 'NOT DEFERRABLE', 'INITIALLY IMMEDIATE', 'INITIALLY DEFERRED'.
A deferred constraint is checked at commit rather than per statement, which is
what lets you insert rows with circular references inside one transaction. See
constraint deferral for switching an
INITIALLY IMMEDIATE constraint to deferred for one transaction.

Indexes#

Index hints#

import { generateIndexHintSQL } from 'ts-prorm-orm';

generateIndexHintSQL({ useIndex: ['idx_created'], forceIndex: ['idx_status'] }, 'mysql');
// USE INDEX (idx_created) FORCE INDEX (idx_status)
dialect argumentOutput
'mysql', 'mariadb'USE INDEX (idx_created) FORCE INDEX (idx_status)
'sqlserver'WITH (INDEX(idx_created)) (only useIndex)
'mssql', 'postgres', anything elseundefined
useIndex suggests, forceIndex insists, ignoreIndex excludes. Reach for
these last: a hint that helps today becomes wrong when the data distribution
changes. Unlike a missing index, it does not show up as a slow query. It shows
up as a query that stopped improving.
[!CAUTION]
The SQL Server branch matches the string 'sqlserver', not the dialect name
'mssql' that prorm.getDialect() returns. Passing getDialect() on SQL
Server therefore returns undefined, and the hint is silently dropped.

Spatial indexes#

import { generateSpatialIndexSQL } from 'ts-prorm-orm';

generateSpatialIndexSQL('places', 'location', 'places_geo', prorm.getDialect());
Oracle gets CREATE INDEX "places_geo" ON "places" ("location") INDEXTYPE IS MDSYS.SPATIAL_INDEX, and an engine with no spatial index throws. On SQLite the
result is an R*Tree virtual table that you keep in sync with the base table
yourself, not an index on places.

Clustered indexes#

import { generateClusteredSQL } from 'ts-prorm-orm';

generateClusteredSQL({ type: 'clustered', fillFactor: 90 });
// CLUSTERED (FILLFACTOR = 90)
type is 'clustered' or 'nonclustered', lower case. A clustered index
determines physical row order, so a table has at most one.

Statistics targets#

import { generateStatisticsSQL } from 'ts-prorm-orm';

generateStatisticsSQL({ for: 'columns', columns: ['status', 'country'], target: 500 }, 'orders');
// ALTER TABLE orders ALTER COLUMN status SET STATISTICS 500, ALTER COLUMN country SET STATISTICS 500
Raise the target on a column whose distribution is skewed enough that the
planner keeps choosing badly. A status column where 99% of rows share one value
is the usual case. Run ANALYZE orders afterwards; the new target applies from
the next statistics collection.

Queries#

DISTINCT ON#

import { generateDistinctOnSQL } from 'ts-prorm-orm';

generateDistinctOnSQL(['user_id']);
// DISTINCT ON (user_id)
PostgreSQL only. It returns the first row per group, as decided by ORDER BY.
This is the concise way to fetch the latest order per user without a window
function:
import { generateDistinctOnSQL } from 'ts-prorm-orm';

const latest = await prorm.query(
  `SELECT ${generateDistinctOnSQL(['user_id'])} * FROM orders ORDER BY user_id, created_at DESC`,
);
// SELECT DISTINCT ON (user_id) * FROM orders ORDER BY user_id, created_at DESC
The ORDER BY must start with the DISTINCT ON columns; the columns after them
choose which row of each group survives.

TABLESAMPLE#

import { generateTablesampleSQL } from 'ts-prorm-orm';

generateTablesampleSQL({ method: 'BERNOULLI', percentage: 10 });
// TABLESAMPLE BERNOULLI(10)

generateTablesampleSQL({ method: 'SYSTEM', percentage: 1, repeatable: 42 });
// TABLESAMPLE SYSTEM(1) REPEATABLE(42)
BERNOULLI scans and keeps each row with the given probability; SYSTEM picks
whole pages, which is far faster and far less random. For a rough aggregate over
a huge table, SYSTEM is usually the right trade. repeatable fixes the seed,
so the same sample comes back while the table is unchanged.

Cursors#

import { generateCursorSQL } from 'ts-prorm-orm';

generateCursorSQL({ scroll: true, holdable: 'HOLD' }, 'c1');
// DECLARE c1 CURSOR SCROLL WITH HOLD FOR
holdable is 'HOLD' or 'WITHOUT HOLD'. A held cursor survives the
transaction that declared it. For iterating a large result in application code,
prefer streams, which manage the cursor for you.

JSON access#

import { generateJSONExtractSQL, generateJSONSetSQL, generateJSONRemoveSQL } from 'ts-prorm-orm';

generateJSONExtractSQL('data', '$.address.city');
// JSON_EXTRACT(`data`, '$.address.city')

generateJSONExtractSQL('data', '$.address.city', true);
// JSON_UNQUOTE(JSON_EXTRACT(`data`, '$.address.city'))

generateJSONSetSQL('data', '$.address.city', "'Leeds'");
// JSON_SET(`data`, '$.address.city', 'Leeds')

generateJSONRemoveSQL('data', '$.address.zip');
// JSON_REMOVE(`data`, '$.address.zip')
These are MySQL-only (backtick quoting, MySQL function names), and the value
passed to generateJSONSetSQL is spliced in as SQL, so quote it yourself. For
portable JSON access use jsonExtract(), and for
filtering use the JSON operators.

Tables#

Inheritance#

import { generateInheritsSQL } from 'ts-prorm-orm';

generateInheritsSQL({ parentTable: 'events' });
// INHERITS (events)
PostgreSQL table inheritance. Constraints and indexes are not inherited, and
a query against the parent scans the children unless you write ONLY.
Declarative partitioning is usually the better tool.

Tablespaces#

import { generateTablespaceSQL } from 'ts-prorm-orm';

generateTablespaceSQL({ name: 'fast_ssd' }, prorm.getDialect());
DialectOutput
PostgreSQLTABLESPACE fast_ssd
MySQL, MariaDBTABLESPACE = fast_ssd
SQLite and the restundefined

Compression#

import { generateCompressionSQL } from 'ts-prorm-orm';

generateCompressionSQL({ algorithm: 'lz4' });
// COMPRESSION lz4 (COMPRESS_LEVEL 6)
'pglz' or 'lz4'. This applies to oversized values moved out of line, not to
the row itself.

Replica identity#

import { generateReplicaIdentitySQL } from 'ts-prorm-orm';

generateReplicaIdentitySQL({ type: 'FULL' });
// REPLICA IDENTITY FULL

generateReplicaIdentitySQL({ type: 'INDEX', index: 'orders_pkey' });
// REPLICA IDENTITY INDEX orders_pkey
This decides what logical replication writes for an update or delete. FULL
logs every old column, so downstream consumers can match rows on a table without
a primary key, at a real write cost.

Sessions#

import { generateStatementTimeoutSQL, generateIdleInTransactionTimeoutSQL } from 'ts-prorm-orm';

generateStatementTimeoutSQL(5000);
// SET session statement_timeout = '5000ms'

generateIdleInTransactionTimeoutSQL(60000);
// SET session idle_in_transaction_session_timeout = '60000ms'
Both are PostgreSQL session settings, so on a pooled connection they apply to
whichever connection ran them. See
SQL constants.

What each builder quotes#

BuilderIdentifiersDialect-aware
buildExclusionSQLconstraint name quoted; string elements verbatimPostgreSQL only
generateSpatialIndexSQLquoted per dialect (SQLite's rtree column is not)yes
buildGeneratedAlwaysSQLstring as verbatim; fn()/col() quotedwith a dialect instance
generateStatisticsSQL, generateDistinctOnSQL, generateInheritsSQL, generateTablespaceSQL, generateCursorSQL, generateReplicaIdentitySQL, generateIndexHintSQLverbatimonly where the table above says so
generateJSONExtractSQL / Set / Removebackticks (MySQL)no

Where the rest lives#

Looking forPage
Views, materialized views, triggers, procedures, sequences, row-level security, partitionsSchema objects
Check constraints, foreign keys, unique and partial indexesIndexes & constraints
fn(), col(), literal(), window functions, aggregatesSQL functions
Session settings, isolation levels, pragmasSQL constants
Raw statements and bound parametersRaw queries
DDL from code, outside a migrationQuery interface

Related reading#

Schema objects — views, triggers, sequences and the rest
Indexes & constraints
Query interface
Modified at 2026-10-04 00:40:16
Previous
SQL constants
Next
SQL function builders
Built with