1. dialects
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. dialects

Amazon RDS for Db2 Dialect

Overview#

Amazon RDS for Db2
is IBM Db2 LUW run by AWS, reached through the same ibm_db (CLI/ODBC)
driver, so RdsDb2Dialect extends DB2Dialect and inherits all of its
SQL. What changes: nobody has SYSADM, SYSCTRL, SYSMAINT or SECADM, so
instance-level work is done by rdsadmin.* stored procedures called from the
rdsadmin database; the commands they replace are refused; and TLS uses a
second port with the RDS CA.
PropertyValue
Dialect namerdsdb2
ExtendsDB2Dialect
Driveribm_db — no extra package
Default port50000 (non-SSL); the SSL port is SSL_SVCENAME
AuthPassword (no Kerberos, no IAM)
Cloud SDKnone
Local runtimenone — hosted service only

Quick start#

Install#

$ npm install ts-prorm-orm ibm_db
$ pnpm add ts-prorm-orm ibm_db
$ yarn add ts-prorm-orm ibm_db
$ bun add ts-prorm-orm ibm_db
ibm_db is the same driver the db2 dialect uses.

Connect#

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

export const db = new Prorm({
  dialect: 'rdsdb2',
  host: 'db2.abc123.us-east-1.rds.amazonaws.com',
  database: 'TESTDB',
  username: 'admin',
  password: process.env.DB_PASSWORD,
});
import { Prorm } from 'ts-prorm-orm';

export const db = new Prorm({
  dialect: 'rdsdb2',
  url: 'rdsdb2://admin:secret@db2.abc123.us-east-1.rds.amazonaws.com:50000/TESTDB',
});
A URL is folded into host, port, database, username and password before the dialect is built; any of those passed alongside it wins.

Define a model#

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

const User = db.define('User', {
  id: { type: DataTypes.INTEGER(), primaryKey: true, autoIncrement: true },
  email: { type: DataTypes.STRING(255), allowNull: false, unique: true },
  name: { type: DataTypes.STRING(100) },
});

await db.sync(); // CREATE TABLE — see Generated SQL below

Query#

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

await User.create({ email: 'ada@example.com', name: 'Ada' });

const page = await User.findAll({
  where: { name: { [Op.like]: 'A%' } },
  order: [['id', 'ASC']],
  limit: 20,
  offset: 40,
});

Generated SQL#

Each block is the statement the model call above it hands the dialect's query(), captured with the driver stubbed out. The model layer inlines the values.

Create table#

db.sync() for the model in the Quick start:
CREATE TABLE

Insert, update and delete#

await User.create({ email: 'ada@example.com', name: 'Ada' });
await User.update({ name: 'Grace' }, { where: { email: 'ada@example.com' } });
await User.destroy({ where: { id: 1 } });

Upsert#

await User.upsert({ id: 1, email: 'ada@example.com', name: 'Ada Lovelace' });
MERGE statement
upsert() also reads the row by primary key before and after the write, to return the instance.

Pagination#

await User.findAll({
  where: { name: { [Op.like]: 'A%' } },
  order: [['id', 'ASC']],
  limit: 20,
  offset: 40,
});

Transaction with a savepoint#

await db.transaction(async (t) => {
  await User.create({ email: 'grace@example.com', name: 'Grace' }, { transaction: t });
  // A nested transaction is a SAVEPOINT; its failure undoes only its own work.
  await db
    .transaction(async (sp) => {
      await User.destroy({ where: { id: 1 }, transaction: sp });
      throw new Error('keep the row');
    }, { transaction: t })
    .catch(() => {});
});
Type mapping for the portable descriptors: STRING → VARCHAR(255), auto-increment INTEGER → INTEGER, BOOLEAN → BOOLEAN, DATE → TIMESTAMP, UUID → CHAR(36), JSON → CLOB. The type comparison lines the major engines up side by side.

Connection and TLS#

const db = new Prorm({
  dialect: 'rdsdb2',
  host: 'db2.abc123.us-east-1.rds.amazonaws.com',
  database: 'TESTDB',
  username: 'admin',
  password: process.env.DB_PASSWORD,
  dialectOptions: {
    tls: { port: 50443, caPath: '/etc/ssl/rds/global-bundle.pem' }, // or $PRORM_RDS_CA_BUNDLE
  },
});
TLS on RDS for Db2 is a second port: set DB2COMM to TCPIP,SSL (or SSL)
and SSL_SVCENAME to a port in a custom parameter group. With tls, the
connection string uses that port and adds SECURITY=SSL;SSLServerCertificate=<bundle>
— the keywords AWS's node-ibm_db example uses. connect() first checks the
bundle exists and is PEM (CloudAuthError INVALID_CONFIG with the download
URL otherwise). IAM database authentication is not available for Db2.

What differs from DB2#

RdsDb2Dialect extends DB2Dialect (db2) and
overrides 35 of its methods (Object.getOwnPropertyNames(RdsDb2Dialect.prototype),
computed by the scratch test); everything else is inherited unchanged.
AreaOverridden
Connection and executionconnect, query
DML buildersbuildSetArchiveLogRetentionCall, buildUpdateDbParamCall
DDL and schemabuildAddGroupsCall, buildAddUserCall, buildCreateDatabaseCall, buildCreateRoleCall, buildDbadmGrantCall, buildDbadmRevokeCall, buildDropDatabaseCall, buildDropRoleCall, buildGrantRoleCall, buildRevokeRoleCall, createDatabaseSQL, dropDatabaseSQL
IntrospectionassertAllowedOnRds, isRdsadmin
OtherbuildActivateDatabaseCall, buildBackupDatabaseCall, buildChangePasswordCall, buildCompleteRollforwardCall, buildDeactivateDatabaseCall, buildForceApplicationCall, buildGetTaskStatusSql, buildListUsersCall, buildReactivateDatabaseCall, buildRemoveGroupsCall, buildRemoveUserCall, buildRestoreDatabaseCall, buildRollforwardDatabaseCall, buildRollforwardStatusCall, dbadmCall, forRdsadmin, runRdsadmin

The rdsadmin database#

The rdsadmin.* procedures must be called while connected to the
rdsadmin database as the master user
. forRdsadmin() returns a dialect
with the same options pointed at it; runRdsadmin(call) refuses to run
anywhere else and binds the procedure's ? output marker as an ibm_db
OUTPUT parameter:
const admin = (db.dialect as RdsDb2Dialect).forRdsadmin();
await admin.connect();
await admin.runRdsadmin(admin.buildCreateDatabaseCall({ database: 'SALES', pageSize: 8192 }));
await admin.query(admin.buildGetTaskStatusSql({ database: 'SALES' })); // tasks are asynchronous

What it refuses#

query() runs assertAllowedOnRds() first, also on the command text inside
SYSPROC.ADMIN_CMD('...'):
CommandUse instead (from rdsadmin)
CREATE DATABASE / DROP DATABASE (also createDatabaseSQL() / dropDatabaseSQL())rdsadmin.create_database / drop_database
BACKUP DATABASErdsadmin.backup_database (to S3)
RESTORE DATABASErdsadmin.restore_database (from S3)
ROLLFORWARD DATABASErdsadmin.rollforward_database
UPDATE DB CFGrdsadmin.update_db_param
UPDATE DBM CFGDB parameter group
FORCE APPLICATIONrdsadmin.force_application
ACTIVATE / DEACTIVATE DATABASErdsadmin.activate_database / deactivate_database
GRANT/REVOKE DBADM, ACCESSCTRL, DATAACCESS ON DATABASErdsadmin.dbadm_grant / dbadm_revoke (needs SECADM otherwise)
anything granting SECADMNot available to any RDS user
Ordinary grants (GRANT CONNECT ... ON DATABASE, GRANT ROLE ...), DDL and
ADMIN_CMD('REORG ...') are unaffected.

rdsadmin builders#

Each returns { sql, values } — values is [] or the single OUTPUT
descriptor. Arguments are positional, as AWS documents them; optional trailing
arguments that are not given are omitted, and a gap before a given one is
refused.
BuilderProcedure
buildCreateDatabaseCallcreate_database(name, page_size, code_set, territory, collation, autoconfigure, non_restrictive)
buildDropDatabaseCalldrop_database(name)
buildActivateDatabaseCall / buildDeactivateDatabaseCall / buildReactivateDatabaseCall(?, name)
buildUpdateDbParamCallupdate_db_param(name, parameter, value[, restart])
buildBackupDatabaseCallbackup_database(?, name, bucket, prefix, ONLINE|OFFLINE[, compression, util_impact_priority, num_files, parallelism, num_buffers])
buildRestoreDatabaseCallrestore_database(?, name, bucket, prefix, timestamp, ONLINE|OFFLINE)
buildRollforwardDatabaseCallrollforward_database(?, name, bucket, prefix, END_OF_LOGS|END_OF_BACKUP|ts, TRUE|FALSE)
buildRollforwardStatusCall / buildCompleteRollforwardCall(?, name)
buildForceApplicationCallforce_application(?, 'ALL' | 'h1, h2')
buildSetArchiveLogRetentionCallset_archive_log_retention(?, name, hours) — 0–840, not on rdsadmin
buildAddUserCall / buildChangePasswordCall / buildRemoveUserCall / buildListUsersCalluser management
buildAddGroupsCall / buildRemoveGroupsCall(username, 'g1,g2')
buildCreateRoleCallcreate_role(database, role)
buildGrantRoleCall / buildRevokeRoleCall / buildDropRoleCall(?, database, role[, grantee[, admin_option]])
buildDbadmGrantCall / buildDbadmRevokeCall(?, database, 'DBADM,ACCESSCTRL,DATAACCESS', grantee)
buildGetTaskStatusSqlSELECT ... FROM TABLE(rdsadmin.get_task_status(id, database, type))

References#

Connecting (no SYSADM/SYSCTRL/SECADM/SYSMAINT)
Stored procedure reference
Considerations (connect to rdsadmin)
Database procedures
Privilege procedures
get_task_status
SSL/TLS

Capabilities#

Computed from the code — capabilitiesOf() (src/transaction-support.ts),
whereSupportOf() (src/query-builders/expression-render.ts),
sqlObjectCapabilitiesOf() (src/sql-objects/capabilities.ts) and the
builders — by the scratch test described in the
capability matrix.
Capabilityrdsdb2
Transactions atomicyes
Savepointsyes
Isolationup to SERIALIZABLE; native levels UR, CS, RS, RR
Transaction modesread-only no; deferrable no; constraint deferral no
RETURNINGnot emitted; returning is accepted and ignored
UpsertMERGE INTO … WHEN MATCHED / WHEN NOT MATCHED
JSON columnCLOB (JSONB → BLOB)
Vector columnVECTOR(3, FLOAT32)
Array columnVARCHAR(255)
WHERE builder32 operator keys; $and/$or/$not; $exists: yes; $in subquery: yes; expression operands: yes
SQL objectsfamily db2: triggers yes; procedures yes; functions multiStatement; materialized views native; sequences yes; enums check; RLS no
StreamingqueryStream() present; LISTEN absent; createExtension() present

Testing#

tests/dialects/rdsdb2.test.ts exercises the dialect with a mocked driver, so nothing touches a server.

See also#

All dialects — the family tree and the capability matrix
db2 — the parent dialect this one extends
Modified at 2026-10-04 00:40:16
Previous
Aurora RDS Data API Dialect (`rdsdata`)
Next
Amazon RDS for MariaDB Dialect
Built with