Database types & coverage

prorm supports databases across every major data-model category. This is the
canonical taxonomy — each type has at least 4 supported engines. SQL engines
are Dialect implementations under src/dialects/*; everything else is a
NoSqlStore under src/nosql/*.

Verification note. Every engine below has a SQL-generation / adapter-logic
unit test suite (connection-free). NoSQL stores lazy-load their driver and
accept an injected client, so they are testable without the driver installed
or a live server. Live end-to-end verification against each engine is separate
(gated INTEGRATION=1 suites) and depends on the instances being reachable.

#	Database type	Engines	Count
1	Relational (OLTP)	SQLite, MySQL, PostgreSQL, MariaDB, Oracle, MSSQL, IBM Db2, Firebird, Turso/libSQL, openGauss, Dolt	11
2	Warehouse / OLAP / columnar	ClickHouse, DuckDB, MotherDuck, Amazon Redshift, Snowflake, Vertica, Greenplum, Exasol, SAP HANA, Databricks, Trino, Presto, Google BigQuery, Amazon Athena, Azure Synapse, Microsoft Fabric, Teradata, MonetDB, Yellowbrick, Apache Doris, StarRocks, Apache Druid	22
3	NewSQL / distributed SQL	CockroachDB, YugabyteDB, TiDB, SingleStore, Google Cloud Spanner (GoogleSQL and PostgreSQL interfaces), OceanBase, PolarDB, Citus, Vitess, Aurora DSQL	11
4	Document	MongoDB, Couchbase, RethinkDB, SurrealDB, ArangoDB	5
5	Key-value	Redis, Memcached, etcd, DynamoDB, Aerospike	5
6	Wide-column	Cassandra, ScyllaDB, Amazon Keyspaces, HBase, Google Bigtable	5
7	Graph	Neo4j, ArangoDB, TigerGraph, Amazon Neptune, Dgraph	5
8	Vector	Pinecone, Milvus, Qdrant, Weaviate, Chroma, Cloudflare Vectorize	6
9	Time-series and streaming SQL	InfluxDB, TimescaleDB, QuestDB, CrateDB, ParadeDB, Materialize, RisingWave, Prometheus, VictoriaMetrics	9
10	Search	Elasticsearch, OpenSearch, Meilisearch, Typesense, Apache Solr	5
11	Object / blob storage	Amazon S3, Google Cloud Storage, Azure Blob Storage, MinIO, Cloudflare R2	5
12	Streaming / message queue	Apache Kafka, NATS, RabbitMQ, Apache Pulsar, Redpanda	5
13	In-memory data grid	Hazelcast, Apache Ignite, GridGain, Infinispan, Apache Geode, Oracle Coherence	6
14	Embedded storage engine	RocksDB, LevelDB, LMDB, UnQLite, NeDB, PouchDB	6
15	Ledger / immutable	Amazon QLDB, immudb, BigchainDB, TerminusDB, Fluree, ProvenDB	6
16	Multi-model	Azure Cosmos DB, FaunaDB, OrientDB, MarkLogic, Google Firestore, RavenDB	6
17	RDF / triplestore (semantic)	Apache Jena Fuseki, Ontotext GraphDB, Stardog, Blazegraph, Virtuoso, AllegroGraph	6
18	Real-time OLAP	Apache Druid, Apache Pinot, StarRocks, Apache Doris, Rockset, Materialize	6
19	Cloud pub/sub & event streaming	AWS Kinesis, Azure Event Hubs, Google Pub/Sub, Amazon SQS, Amazon SNS, EventStoreDB, Cloudflare Queues	7
20	Edge / serverless KV	Cloudflare KV, Vercel KV, Upstash, Deno KV, Momento, AWS DAX, Cloudflare Durable Objects	7
21	Job / task queue	Beanstalkd, Gearman, BullMQ, NSQ, Resque, Bee-Queue	6
22	Log / observability	Grafana Loki, Splunk, Graylog, Sumo Logic, SigNoz, Papertrail	6
23	Serverless / HTTP SQL	Cloudflare D1, rqlite, Aurora RDS Data API, Redshift Data API	4
24	Managed cloud editions of SQL engines	RDS and Aurora (PostgreSQL, MySQL, MariaDB, SQL Server, Oracle, Db2), Azure SQL Database and Managed Instance, Azure Database for PostgreSQL and MySQL, Cosmos DB for PostgreSQL, Kusto, Cloud SQL (PostgreSQL, MySQL, SQL Server), AlloyDB and Omni, Oracle Autonomous, MySQL HeatWave, Neon, Supabase	23

Several engines are multi-model and appear under their primary category:
ArangoDB (document + graph), SurrealDB (document/multi-model), CrateDB & QuestDB
(SQL + time-series), TimescaleDB (relational + time-series), Redis (key-value +
streams). Databricks/Trino/Vertica/Exasol/Firebird are SQL-generation dialect
layers — see the dialect pages for their driver/wire
caveats.

Totals

SQL dialects: 77 (SQL_DIALECTS.length in src/dialect-names.ts; one directory each under src/dialects/*)

NoSQL / data stores: 105 (the directories under src/nosql/* other than shared and the promql compiler)

Distinct database types: 24 in the table above (182 engines: 77 dialects and 105 stores)

Counts computed on 2026-09-26 with ls -d src/nosql/*/ and a scratch test over SQL_DIALECTS; the SQL rows follow the grouping of the dialect index.

Type mapping across engines

The same model column becomes a different column type on each engine. Each
dialect's getDataTypeSql() decides, and typeMapping picks which of its two
mappings applies:

Opt in per connection:

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

const db = new Prorm({
  dialect: 'postgres',
  host: 'localhost',
  database: 'app',
  typeMapping: 'modern',
});

The tables are computed, not written by hand: every dialect built through
new Prorm() with its driver stubbed, and getDataTypeSql() called on each
DataTypes constructor. In the modern table, bold cells differ from the
legacy mapping.

Type	PostgreSQL	MySQL	SQLite	SQL Server	Oracle	Snowflake	BigQuery	ClickHouse	DuckDB
`STRING()`	`VARCHAR(255)`	`VARCHAR(255)`	`VARCHAR(255)`	`NVARCHAR(255)`	`VARCHAR2(255)`	`VARCHAR(255)`	`STRING`	`String`	`VARCHAR(255)`
`STRING(100)`	`VARCHAR(100)`	`VARCHAR(100)`	`VARCHAR(100)`	`NVARCHAR(100)`	`VARCHAR2(100)`	`VARCHAR(100)`	`STRING`	`String`	`VARCHAR(100)`
`TEXT()`	`TEXT`	`TEXT`	`TEXT`	`NVARCHAR(MAX)`	`CLOB`	`VARCHAR`	`STRING`	`String`	`VARCHAR`
`CHAR(2)`	`CHAR(2)`	`CHAR(2)`	`CHAR(2)`	`CHAR(2)`	`CHAR(2)`	`CHAR(2)`	`STRING`	`String`	`VARCHAR(2)`
`INTEGER()`	`INTEGER`	`INT`	`INTEGER`	`INT`	`NUMBER(10)`	`NUMBER(38,0)`	`INT64`	`Int32`	`INTEGER`
`BIGINT()`	`BIGINT`	`BIGINT`	`BIGINT`	`BIGINT`	`NUMBER(19)`	`NUMBER(38,0)`	`INT64`	`Int64`	`BIGINT`
`SMALLINT()`	`VARCHAR(255)`	`VARCHAR(255)`	`TEXT`	`NVARCHAR(255)`	`VARCHAR2(255)`	`VARCHAR(255)`	`STRING`	`String`	`VARCHAR`
`FLOAT()`	`REAL`	`FLOAT`	`FLOAT(10,2)`	`FLOAT`	`FLOAT`	`FLOAT`	`FLOAT64`	`Float32`	`REAL`
`DOUBLE()`	`DOUBLE PRECISION`	`DOUBLE`	`DOUBLE(10,2)`	`FLOAT`	`FLOAT`	`DOUBLE`	`FLOAT64`	`Float64`	`DOUBLE`
`DECIMAL(10, 2)`	`DECIMAL(10,2)`	`DECIMAL(10,2)`	`DECIMAL(10,2)`	`DECIMAL(10,2)`	`NUMBER(10,2)`	`NUMBER(10,2)`	`NUMERIC(10,2)`	`Decimal(10, 2)`	`DECIMAL(10,2)`
`BOOLEAN()`	`BOOLEAN`	`TINYINT(1)`	`INTEGER`	`BIT`	`NUMBER(1)`	`BOOLEAN`	`BOOL`	`Bool`	`BOOLEAN`
`DATE()`	`TIMESTAMP`	`DATETIME`	`DATETIME`	`DATETIME2`	`DATE`	`TIMESTAMP_NTZ`	`TIMESTAMP`	`DateTime`	`TIMESTAMP`
`DATEONLY()`	`DATE`	`DATE`	`DATE`	`DATE`	`DATE`	`DATE`	`DATE`	`Date`	`DATE`
`TIME()`	`TIME`	`TIME`	`TIME`	`TIME`	`VARCHAR2(8)`	`TIME`	`TIME`	`String`	`TIME`
`UUID()`	`UUID`	`CHAR(36)`	`TEXT`	`UNIQUEIDENTIFIER`	`RAW(16)`	`VARCHAR(36)`	`STRING`	`UUID`	`UUID`
`JSON()`	`JSON`	`JSON`	`TEXT`	`NVARCHAR(MAX)`	`CLOB`	`VARIANT`	`JSON`	`String`	`JSON`
`JSONB()`	`JSONB`	`JSON`	`TEXT`	`NVARCHAR(MAX)`	`BLOB`	`VARIANT`	`JSON`	`String`	`JSON`
`BLOB()`	`BYTEA`	`BLOB`	`BLOB`	`VARBINARY(MAX)`	`BLOB`	`BINARY`	`BYTES`	`String`	`BLOB`
`ENUM('a', 'b')`	`VARCHAR(255)`	`ENUM('a','b')`	`TEXT CHECK(value IN ('a','b'))`	`NVARCHAR(255)`	`VARCHAR2(255)`	`VARCHAR`	`STRING`	`Enum8('a' = 1, 'b' = 2)`	`VARCHAR CHECK(value IN ('a','b'))`
`ARRAY(INTEGER())`	`INTEGER[]`	`VARCHAR(255)`	`TEXT`	`NVARCHAR(255)`	`VARCHAR2(255)`	`ARRAY`	`ARRAY<INT64>`	`Array(Int32)`	`INTEGER[]`
`VECTOR(3)`	`VECTOR(3)`	`VECTOR(3)`	refused	`VECTOR(3)`	`VECTOR(3, FLOAT32)`	`VECTOR(FLOAT, 3)`	`ARRAY<FLOAT64>`	`Array(Float32)`	`FLOAT[3]`

Type	PostgreSQL	MySQL	SQLite	SQL Server	Oracle	Snowflake	BigQuery	ClickHouse	DuckDB
`STRING()`	`VARCHAR(255)`	`VARCHAR(255)`	`VARCHAR(255)`	`NVARCHAR(255)`	`VARCHAR2(255)`	`VARCHAR(255)`	`STRING(255)`	`String`	`VARCHAR(255)`
`STRING(100)`	`VARCHAR(100)`	`VARCHAR(100)`	`VARCHAR(100)`	`NVARCHAR(100)`	`VARCHAR2(100)`	`VARCHAR(100)`	`STRING(100)`	`String`	`VARCHAR(100)`
`TEXT()`	`TEXT`	`TEXT`	`TEXT`	`NVARCHAR(MAX)`	`CLOB`	`VARCHAR`	`STRING`	`String`	`VARCHAR`
`CHAR(2)`	`CHAR(2)`	`CHAR(2)`	`CHAR(2)`	`NCHAR(2)`	`CHAR(2)`	`CHAR(2)`	`STRING(2)`	`String`	`VARCHAR(2)`
`INTEGER()`	`INTEGER`	`INT`	`INTEGER`	`INT`	`NUMBER(10)`	`NUMBER(38,0)`	`INT64`	`Int32`	`INTEGER`
`BIGINT()`	`BIGINT`	`BIGINT`	`BIGINT`	`BIGINT`	`NUMBER(19)`	`NUMBER(38,0)`	`INT64`	`Int64`	`BIGINT`
`SMALLINT()`	`SMALLINT`	`SMALLINT`	`SMALLINT`	`SMALLINT`	`NUMBER(5)`	`NUMBER(38,0)`	`INT64`	`Int16`	`SMALLINT`
`FLOAT()`	`REAL`	`FLOAT`	`FLOAT`	`REAL`	`BINARY_FLOAT`	`FLOAT`	`FLOAT64`	`Float32`	`REAL`
`DOUBLE()`	`DOUBLE PRECISION`	`DOUBLE`	`DOUBLE`	`FLOAT`	`BINARY_DOUBLE`	`DOUBLE`	`FLOAT64`	`Float64`	`DOUBLE`
`DECIMAL(10, 2)`	`DECIMAL(10,2)`	`DECIMAL(10,2)`	`DECIMAL(10,2)`	`DECIMAL(10,2)`	`NUMBER(10,2)`	`NUMBER(10,2)`	`NUMERIC(10,2)`	`Decimal(10, 2)`	`DECIMAL(10,2)`
`BOOLEAN()`	`BOOLEAN`	`TINYINT(1)`	`INTEGER`	`BIT`	`NUMBER(1)`	`BOOLEAN`	`BOOL`	`Bool`	`BOOLEAN`
`DATE()`	`TIMESTAMP`	`DATETIME`	`DATETIME`	`DATETIME2`	`TIMESTAMP`	`TIMESTAMP_NTZ`	`DATETIME`	`DateTime`	`TIMESTAMP`
`DATEONLY()`	`DATE`	`DATE`	`DATE`	`DATE`	`DATE`	`DATE`	`DATE`	`Date`	`DATE`
`TIME()`	`TIME`	`TIME`	`TIME`	`TIME`	`INTERVAL DAY(0) TO SECOND(6)`	`TIME`	`TIME`	`String`	`TIME`
`UUID()`	`UUID`	`CHAR(36)`	`TEXT`	`UNIQUEIDENTIFIER`	`RAW(16)`	`VARCHAR(36)`	`STRING`	`UUID`	`UUID`
`JSON()`	`JSON`	`JSON`	`TEXT`	`NVARCHAR(MAX)`	`CLOB`	`VARIANT`	`JSON`	`String`	`JSON`
`JSONB()`	`JSONB`	`JSON`	`TEXT`	`NVARCHAR(MAX)`	`BLOB`	`VARIANT`	`JSON`	`String`	`JSON`
`BLOB()`	`BYTEA`	`BLOB`	`BLOB`	`VARBINARY(MAX)`	`BLOB`	`BINARY`	`BYTES`	`String`	`BLOB`
`ENUM('a', 'b')`	`VARCHAR(255)`	`ENUM('a','b')`	`TEXT CHECK(value IN ('a','b'))`	`NVARCHAR(255)`	`VARCHAR2(255)`	`VARCHAR`	`STRING`	`Enum8('a' = 1, 'b' = 2)`	`ENUM('a', 'b')`
`ARRAY(INTEGER())`	`INTEGER[]`	`JSON`	`TEXT`	refused	refused	`ARRAY`	`ARRAY<INT64>`	`Array(Int32)`	`INTEGER[]`
`VECTOR(3)`	`VECTOR(3)`	`VECTOR(3)`	refused	`VECTOR(3)`	`VECTOR(3, FLOAT32)`	`VECTOR(FLOAT, 3)`	`ARRAY<FLOAT64>`	`Array(Float32)`	`FLOAT[3]`

[!WARNING] Silent fallbacks in the legacy mapping
A key the dialect's legacy mapping does not know falls back to
VARCHAR(255): SMALLINT() becomes text almost everywhere, and ARRAY()
becomes a string on engines with no array type. The modern mapping fixes the
first and refuses the second (SQL Server, Oracle) rather than store an array
as text.

[!NOTE]
"refused" means getDataTypeSql() throws, with a message naming the
alternative — for example SQLite has no vector type and points at
Turso/libSQL. Every dialect page lists its own full
mapping.

Where each lives

SQL engines: src/dialects/<name>/ — implement the shared Dialect interface.
See dialect docs.

Everything else: src/nosql/<name>/ — implement the minimal NoSqlStore
contract (connect/disconnect/isConnected/getClient) plus an
engine-specific method surface. See store docs.

Stores are imported from their own subpath, not the package root:
import { MongoStore } from 'ts-prorm-orm/nosql/mongodb'; (package.json exports ./nosql/*).

SQL dialects — the relational engines in detail

Data stores — the non-relational adapters

Database types & coverage

Totals#

Type mapping across engines#

Where each lives#

Related reading#

Totals

Type mapping across engines

Where each lives

Related reading