Zum Inhalt springen
Deutsch

Microsoft SQL Server

Das SQL-Server-Backend liefert alle drei Persistence-Komponenten gegen eine einzige SQL-Server-Datenbank, über den mssql-Treiber (intern tedious):

  • MsSqlJournal — das Event-Journal für PersistentActors.
  • MsSqlSnapshotStore — Snapshots, um die Recovery zu begrenzen.
  • MsSqlDurableStateStore — Key-Value-Durable-State für DurableStateActors.

Wie Postgres ist es über Cluster-Nodes geteilt — jeder Node kann jede persistenceId lesen und schreiben — und mssql/tedious ist reines JavaScript, braucht also keinen nativen Build-Schritt und läuft auf allen drei unterstützten Runtimes.

mssql ist eine optionale Peer-Dependency — installiere sie neben actor-ts:

Terminal-Fenster
bun add mssql

Das Framework importiert sie erst, wenn ein SQL-Server-Store öffnet — beim Start, oder bei der ersten Verwendung, wenn das Öffnen beim Start abgeschaltet ist —; bis dahin bleibt sie aus deinem Bundle heraus.

Registriere alle drei Stores über den plugins-Slot der Optionen des Systems und wähle sie in seiner Konfiguration aus. Übergib einen geteilten pool, damit alle drei Komponenten denselben Connection-Pool nutzen:

import sql from 'mssql';
import {
ActorSystem,
ActorSystemOptions,
} from 'actor-ts';
import {
MsSqlDurableStateStoreOptions,
MsSqlJournalOptions,
MsSqlSnapshotStoreOptions,
RegisterMsSqlPluginsOptions,
registerMsSqlPlugins,
} from 'actor-ts/persistence';
const pool = await new sql.ConnectionPool({
server: 'db.example.com',
port: 1433,
user: 'actor_ts',
password: process.env.MSSQL_PASSWORD,
database: 'app',
options: { encrypt: true },
}).connect();
const msSqlSnapshotStoreOptions = MsSqlSnapshotStoreOptions.create()
.withKeepN(3);
const registerOptions = RegisterMsSqlPluginsOptions.create()
// One pool shared by journal + snapshot + durable-state (recommended).
.withPool(pool)
.withJournal(MsSqlJournalOptions.create() /* .withEventsTable(...).withTagsTable(...) */)
.withSnapshotStore(msSqlSnapshotStoreOptions)
.withDurableStateStore(MsSqlDurableStateStoreOptions.create() /* .withTable(...) */);
const systemOptions = ActorSystemOptions.create()
// Select the SQL Server plugins for all three stores.
.withConfig({
'actor-ts': {
persistence: {
journal: { plugin: 'actor-ts.persistence.journal.mssql' },
'snapshot-store': { plugin: 'actor-ts.persistence.snapshot-store.mssql' },
'durable-state': { plugin: 'actor-ts.persistence.durable-state.mssql' },
},
},
})
.withPersistence({ plugins: [(persistence) => registerMsSqlPlugins(persistence, registerOptions)] });
const system = ActorSystem.create('my-app', systemOptions);

Das Plug-in läuft innerhalb von ActorSystem.create, also sind alle drei Stores registriert, bevor create zurückkehrt, und die, die die Konfiguration auswählt, öffnen als Teil des Starts: Eine Datenbank, die der Knoten nicht erreicht, lässt den Start scheitern statt erst die erste persistierte Nachricht — siehe Stores beim Start öffnen. Das gilt auch mit autoCreateTables: false, weil das Öffnen dann ein SELECT 1 schickt, wo es sonst das DDL ausführen würde, und solange das Öffnen beim Start an ist, der Default: Ist das Öffnen beim Start abgeschaltet, wandert der Fehler zur ersten Operation des Stores. Das gilt für diese Stores, nicht für jede Achse: Ein Object-Storage-Snapshot- oder -Durable-State-Store, der daneben ausgewählt ist, oder ein eigener Store ohne start() hat vorab nichts zu öffnen und scheitert stattdessen bei seiner ersten Operation. registerMsSqlPlugins gibt außerdem den Durable-State-Store zurück, falls du ihn lieber von Hand verdrahtest; ein Plug-in behält ihn, indem es das Ergebnis zuweist, (persistence) => { msSql = registerMsSqlPlugins(persistence, registerOptions); }. Seit #872 ist das eine Bequemlichkeit und nicht mehr der einzige Weg, und ein von Hand verdrahteter Store ist kein ausgewählter, er öffnet also bei der ersten Verwendung statt mit dem Start.

Ein geteilter Pool gehört dem Caller: kein Store beendet ihn, du schließt ihn also selbst beim Shutdown. Ohne ihn baut jede Komponente ihren eigenen aus poolConfig / url, wenn sie öffnet, und schließt ihn bei close():

const poolConfig = {
server: 'db.example.com', database: 'app',
user: 'actor_ts', password: process.env.MSSQL_PASSWORD,
options: { encrypt: true },
};
const msSqlJournalOptions = MsSqlJournalOptions.create()
.withPoolConfig(poolConfig);

Die Plugin-Id ist der Config-Abschnitt: Der Block, der nach der Id benannt ist, ist der Block, den dieses Plugin liest (#872). Alles außer den lebenden Objekten kann aus der application.conf kommen, registerMsSqlPlugins(persistence) braucht damit gar keine Optionen mehr:

import { ActorSystem, ActorSystemOptions } from 'actor-ts';
import { registerMsSqlPlugins } from 'actor-ts/persistence';
const systemOptions = ActorSystemOptions.create().withPersistence({
plugins: [(persistence) => registerMsSqlPlugins(persistence)],
});
const system = ActorSystem.create('my-app', systemOptions);
actor-ts.persistence {
journal { plugin = "actor-ts.persistence.journal.mssql" }
snapshot-store { plugin = "actor-ts.persistence.snapshot-store.mssql" }
durable-state { plugin = "actor-ts.persistence.durable-state.mssql" }
journal.mssql { url = ${?MSSQL_URL}, events-table = "events" }
snapshot-store.mssql { url = ${?MSSQL_URL}, keep-n = 5 }
durable-state.mssql { url = ${?MSSQL_URL}, table = "durable_state" }
}

An registerMsSqlPlugins übergebene Optionen gewinnen weiterhin, Feld für Feld, und ein nicht gesetztes Feld fällt auf den Block durch, statt ihn zu leeren — ein geteilter Pool im Code und die Tabellennamen in HOCON sind also eine normale Mischung. Ein vorab gebauter Pool und ein serializer haben gar kein Blatt: Das sind lebende Objekte, die eine Config-Datei nicht ausdrücken kann. poolConfig ebenso wenig — die gesamte Optionsfläche des Treibers, die code-only bleibt. tags-table wird gelesen, wird aber als Kommentar statt als Schlüssel ausgeliefert, weil sein Default aus events-table abgeleitet wird und genau die Abwesenheit beide im Gleichlauf hält.

Was du am Pool tatsächlich einstellst, hat typisierte Blätter (#1490), jedes in der Referenzkonfiguration nur als Kommentar, damit Weglassen den eigenen Default von node-mssql behält:

actor-ts.persistence.journal.mssql {
url = ${?MSSQL_URL} # Server=...;Database=...;Encrypt=true
max-pool-size = 20 # pool.max (default 10)
idle-timeout = 1m # pool.idleTimeoutMillis (default 30s)
connect-timeout = 5s # connectionTimeout (default 15s)
request-timeout = 2m # requestTimeout (default 15s)
ca-file = "/etc/ssl/mssql-ca.pem" # read when the pool opens, verified against by tedious
}

Jedes erreicht den Treiber nur, wenn es gesetzt ist — über die URL gelegt, wie node-mssqls eigener Parser sie liest, damit Server, Datenbank und Zugangsdaten erhalten bleiben. Der Store prüft sie beim Bau: eine Größe oder ein Timeout, das keine positive ganze Zahl ist, oder ein Connect- oder Request-Timeout, länger als ein Timer halten kann, wird mit einem OptionsError abgelehnt — ebenso ein Blatt neben derselben Einstellung in poolConfig oder im Connection-String (max-pool-size neben Max Pool Size, connect-timeout neben Connect Timeout), das dann beide nennt, statt eine Seite still gewinnen zu lassen. ca-file ist ein Pfad, den das Framework liest, nie das Zertifikat selbst.

Eine url, die die TLS-Verifizierung abschaltet, wird abgelehnt. Ein Connection-String, dessen TrustServerCertificate irgendetwas ist, das node-mssql als true liest — true, yes, 1, jeder Wert außer false, no, 0 oder einem leeren —, lässt den Reader einen ConfigError werfen, der das Blatt nennt, in jeder Groß- und Kleinschreibung des Schlüssels und gleich, ob die URL ausgeschrieben oder aus ${?MSSQL_URL} substituiert ist. Für die Datei ist die Ablehnung strikt: Die url des Blocks wird auch dann abgelehnt, wenn registerMsSqlPlugins eine eigene URL oder einen eigenen Pool bekommt. Inspiziert wird nur HOCON — derselbe String, an withUrl(...) übergeben, ist die Entscheidung deines Codes. Ein Connection-String hat keinen Schlüssel für eine CA, ein Server hinter einer privaten CA wird also daneben genannt, mit ca-file; das wird zusammen mit einem Encrypt oder einem TrustServerCertificate abgelehnt, das die CA ungenutzt ließe. Encrypt=false allein ist Klartext statt unverifiziertem TLS und bleibt erlaubt. Die Begründung steht unter TLS everywhere.

durable-state.plugin wählt jetzt den Durable-State-Store dieses Backends aus. Früher wurde er eifrig gebaut und von registerMsSqlPlugins zurückgegeben, ließ sich also nur verdrahten, indem man diese Instanz durch den Anwendungscode reichte. Das zurückgegebene Handle funktioniert weiterhin und liefert dieselbe Instanz — sie wird nur gebaut, wenn sie zum ersten Mal angefragt wird, statt bei der Registrierung, und bei einem ausgewählten Store ist das der Start.

  • SQL Server ist dein System of Record. In vielen Stacks der Enterprise-Default und das primäre Backend von Akka.NET — das hier ist das nächstliegende Gegenstück.
  • Cluster-geteilte Persistenz. Gesharde Entities, die zwischen Nodes wandern, oder Cross-Node-Projections brauchen ein Journal, das jeder Node lesen kann.
  • Du willst ein relationales Backend ohne nativen Treiber. tedious ist reines JavaScript, anders als better-sqlite3.

Für lokale Single-Node-Entwicklung ist SqliteJournal einfacher (eine Datei, kein Server).

type MsSqlConnection = {
url?: string; // Server=…;Database=… (an mssql:// URL is refused)
poolConfig?: Record<string, unknown>; // mssql config object; takes precedence over url
pool?: MsSqlPoolLike; // pre-built / shared pool
maxPoolSize?: number; // pool.max, default 10 (max-pool-size)
idleTimeoutMs?: number; // pool.idleTimeoutMillis, default 30 000 (idle-timeout)
connectTimeoutMs?: number; // connectionTimeout, default 15 000 (connect-timeout)
requestTimeoutMs?: number; // requestTimeout, default 15 000 (request-timeout)
caFile?: string; // PEM file tedious verifies against (ca-file)
};
interface MsSqlJournalOptions extends MsSqlConnection {
eventsTable?: string; // default 'events'
tagsTable?: string; // default '<eventsTable>_tags'
autoCreateTables?: boolean; // default true
}
interface MsSqlSnapshotStoreOptions extends MsSqlConnection {
snapshotsTable?: string; // default 'snapshots'
keepN?: number; // keep newest N per pid; default 3, <=0 keeps all
autoCreateTables?: boolean;
}
interface MsSqlDurableStateStoreOptions extends MsSqlConnection {
table?: string; // default 'durable_state'
autoCreateTables?: boolean;
}

Die Optionen werden bei der Konstruktion des Stores validiert. Tabellennamen kommen aus der Config (nicht von Nutzereingaben) und werden gegen ein Safe-Identifier-Pattern geprüft; alles andere — persistenceIds, Tags, Payloads — geht als benannter Bind-Parameter (@p1, @p2, …) durch und wird nie per String-Konkatenation zusammengesetzt.

Mit autoCreateTables (dem Default) führt das Backend abgesicherte CREATE TABLE-Statements aus, wenn der Store öffnet — beim Start, oder bei der ersten Verwendung, wenn das Öffnen beim Start abgeschaltet ist. T-SQL kennt kein CREATE TABLE IF NOT EXISTS, daher ist jedes in eine IF OBJECT_ID(…) IS NULL-Prüfung gefasst:

CREATE TABLE events (
persistence_id NVARCHAR(255) COLLATE Latin1_General_100_BIN2 NOT NULL,
sequence_nr BIGINT NOT NULL,
payload NVARCHAR(MAX) NOT NULL, -- JSON
tags NVARCHAR(MAX) NULL, -- CSV (zusätzlich in events_tags gespiegelt)
timestamp BIGINT NOT NULL,
CONSTRAINT PK_events PRIMARY KEY (persistence_id, sequence_nr)
);
CREATE TABLE events_tags ( -- indizierte Tag-Lookups für Projections
persistence_id NVARCHAR(255) COLLATE Latin1_General_100_BIN2 NOT NULL,
sequence_nr BIGINT NOT NULL,
tag NVARCHAR(255) COLLATE Latin1_General_100_BIN2 NOT NULL,
timestamp BIGINT NOT NULL,
CONSTRAINT PK_events_tags PRIMARY KEY NONCLUSTERED
(tag, timestamp, persistence_id, sequence_nr)
);
CREATE TABLE events_meta ( -- High-Water-Mark der Kompaktierung
persistence_id NVARCHAR(255) COLLATE Latin1_General_100_BIN2 NOT NULL,
deleted_to BIGINT NOT NULL,
CONSTRAINT PK_events_meta PRIMARY KEY (persistence_id)
);
CREATE TABLE snapshots (
persistence_id NVARCHAR(255) COLLATE Latin1_General_100_BIN2 NOT NULL,
sequence_nr BIGINT NOT NULL,
payload NVARCHAR(MAX) NOT NULL,
timestamp BIGINT NOT NULL,
CONSTRAINT PK_snapshots PRIMARY KEY (persistence_id, sequence_nr)
);
CREATE TABLE durable_state (
persistence_id NVARCHAR(255) COLLATE Latin1_General_100_BIN2 NOT NULL,
revision BIGINT NOT NULL,
payload NVARCHAR(MAX) NOT NULL,
timestamp BIGINT NOT NULL,
CONSTRAINT PK_durable_state PRIMARY KEY (persistence_id)
);

Der Primary Key der Tags-Tabelle ist bewusst nonclustered. NVARCHAR(n) zählt 2n Bytes zum Index-Key, (tag, timestamp, persistence_id, sequence_nr) braucht damit 1036 Bytes — über dem 900-Byte-Limit für clustered Indizes, aber innerhalb des 1700-Byte-Limits für nonclustered. Genau deshalb ist SQL Server 2016 oder neuer Voraussetzung. Die Kollation ist Metadatum, keine Breite, und kostet in diesem Budget also nichts.

Leg die Tabellen vorab an (mit nur INSERT/SELECT/UPDATE/DELETE-Rechten) und setze autoCreateTables: false, wenn die Datenbankrolle kein DDL ausführen darf. Ist es aus, schickt der Store ein SELECT 1, wo er sonst das DDL ausführen würde, und erreicht die Datenbank also trotzdem, wenn er öffnet.

Jede persistence_id- und tag-Spalte trägt ein explizites COLLATE Latin1_General_100_BIN2. Ohne das erbt die Spalte den Datenbank-Standard — SQL_Latin1_General_CP1_CI_AS auf einer Standardinstanz, und der ist case-insensitiv.

Eine persistence_id ist nicht bloß ein Wert: sie ist der Name eines Event-Streams und die Hälfte des events-Primary-Keys. Unter einer faltenden Kollation sind Alice und alice deshalb ein Stream hier und zwei auf Postgres, SQLite, MongoDB und DynamoDB. Ein als Alice gestarteter Actor liest alices Events, faltet sie in seinen eigenen State und schreibt in alices Stream — ein Cross-Entity-Read, dessen einziges Symptom eine Serie von JournalConcurrencyErrors ist, die wie ein Speicherfehler aussieht. Dieselbe Spalte ist der Schlüssel für Durable-State-Load, Revisions-CAS und Delete; dort überschreibt und löscht eine Kollision den State einer anderen Entität.

Eine Id-Validierung kann das nicht beheben: Alice und alice sind beide völlig legale Ids. Was sich unterscheidet, ist der Vergleich, und der ist eine Eigenschaft der Spalte.

BIN2 vergleicht nach Unicode-Codepoint, so wie es jedes andere Backend ohnehin tut. Der Latin1_General-Teil des Namens wählt nur eine Codepage für Nicht-Unicode-Typen; auf NVARCHAR ist er wirkungslos, das hier ist also ein vollständig unicodefähiger Ordinalvergleich und keine westeuropäische Einschränkung. Version 100 gibt es seit SQL Server 2008 und damit weit unterhalb der 2016er-Grenze, die der nonclustered Key der Tags-Tabelle ohnehin setzt.

Das DDL ist mit IF OBJECT_ID(…) IS NULL abgesichert, und autoCreateTables ist standardmäßig true — eine bestehende Datenbank übernimmt das also nicht: das Framework fasst eine vorgefundene Tabelle nie wieder an. Neue Deployments bekommen die Kollation stillschweigend; eine ältere Datenbank behält den Instanz-Standard, bis du die Migration unten ausführst — aber nicht mehr unbemerkt. Jeder Store liest seine eigenen Tabellen aus sys.columns, wenn er öffnet, und warnt, wenn eine persistence_id- oder tag-Spalte mit einer nicht-binären Kollation zurückkommt; er nennt Tabelle, Spalte und die gefundene Kollation. Ein ausgewählter Store öffnet als Teil des Starts, die Warnung steht also im Startlog; ist das Öffnen beim Start abgeschaltet, verbindet sich der Store erst bei Bedarf und warnt beim ersten Zugriff, also bei der ersten Persistenz-Operation. Dieser Lesezugriff braucht keine DDL-Rechte und läuft unabhängig davon, ob autoCreateTables gesetzt ist — denn ein vom Betrieb selbst verwaltetes Schema, also genau der Fall, den diese Seite zum Vorab-Anlegen empfiehlt, ist am ehesten älter als der Pin.

SQL Server weigert sich, eine Spalte umzukollationieren, von der ein Index oder Constraint abhängt (Fehler 5074) — pro Tabelle heißt das also: droppen, ändern, neu anlegen. Führe das einmal pro Datenbank aus, als eine Transaktion, während kein Knoten schreibt:

SET XACT_ABORT ON;
BEGIN TRANSACTION;
ALTER TABLE events DROP CONSTRAINT PK_events;
DROP INDEX idx_events_pid ON events;
ALTER TABLE events ALTER COLUMN persistence_id
NVARCHAR(255) COLLATE Latin1_General_100_BIN2 NOT NULL;
ALTER TABLE events ADD CONSTRAINT PK_events
PRIMARY KEY (persistence_id, sequence_nr);
CREATE INDEX idx_events_pid ON events (persistence_id);
ALTER TABLE events_tags DROP CONSTRAINT PK_events_tags;
DROP INDEX idx_events_tags_pid_seq ON events_tags;
ALTER TABLE events_tags ALTER COLUMN persistence_id
NVARCHAR(255) COLLATE Latin1_General_100_BIN2 NOT NULL;
ALTER TABLE events_tags ALTER COLUMN tag
NVARCHAR(255) COLLATE Latin1_General_100_BIN2 NOT NULL;
ALTER TABLE events_tags ADD CONSTRAINT PK_events_tags
PRIMARY KEY NONCLUSTERED (tag, timestamp, persistence_id, sequence_nr);
CREATE INDEX idx_events_tags_pid_seq ON events_tags (persistence_id, sequence_nr);
ALTER TABLE events_meta DROP CONSTRAINT PK_events_meta;
ALTER TABLE events_meta ALTER COLUMN persistence_id
NVARCHAR(255) COLLATE Latin1_General_100_BIN2 NOT NULL;
ALTER TABLE events_meta ADD CONSTRAINT PK_events_meta PRIMARY KEY (persistence_id);
ALTER TABLE snapshots DROP CONSTRAINT PK_snapshots;
ALTER TABLE snapshots ALTER COLUMN persistence_id
NVARCHAR(255) COLLATE Latin1_General_100_BIN2 NOT NULL;
ALTER TABLE snapshots ADD CONSTRAINT PK_snapshots
PRIMARY KEY (persistence_id, sequence_nr);
ALTER TABLE durable_state DROP CONSTRAINT PK_durable_state;
ALTER TABLE durable_state ALTER COLUMN persistence_id
NVARCHAR(255) COLLATE Latin1_General_100_BIN2 NOT NULL;
ALTER TABLE durable_state ADD CONSTRAINT PK_durable_state PRIMARY KEY (persistence_id);
COMMIT;

ALTER COLUMN ersetzt die gesamte Definition, NOT NULL muss also wiederholt werden — lässt du es weg, wird die Spalte stillschweigend nullable. Setze deine eigenen Tabellennamen ein, wenn du eventsTable, tagsTable, snapshotsTable oder table überschrieben hast.

Die Transaktion ist kein Zeremoniell. Tag-Queries joinen events_tags über persistence_id an events, und zwischen dem Block, der events umkollationiert, und dem Block, der events_tags umkollationiert, tragen die beiden Spalten verschiedene Kollationen — SQL Server verweigert den Join dann rundheraus mit Fehler 468, Cannot resolve the collation conflict: ein hartes Scheitern, keine falsche Antwort, nichts weiter unten kann es also überdecken. DDL ist auf SQL Server transaktional, und genau das schließt dieses Fenster: ein Leser blockiert bis zum COMMIT am Schema-Lock, statt den gemischten Zustand zu sehen, und mit eingeschaltetem XACT_ABORT rollt ein scheiterndes Statement — etwa ein Index, der anders heißt als der Standard — den gesamten Batch zurück, statt die Hälfte der Tabellen umgestellt zurückzulassen. Beides ersetzt nicht das Anhalten der Writer; es macht das Fenster unsichtbar für das, was du anzuhalten vergessen hast.

Derselbe Konflikt ist dauerhaft statt vorübergehend bei einer tagsTable, die auf eine neue Tabelle neben einem alten events zeigt: die neue Tabelle wird mit dem BIN2-Pin angelegt, die alte behält den Instanz-Standard, und jede Tag-Query scheitert mit 468, bis auch events umkollationiert ist.

Die Startwarnung meldet pro Spalte, und genau das unterscheidet diesen Zustand von einem unangetasteten Schema: sie nennt nur die Spalten, die noch auf einer faltenden Kollation stehen, und sagt, dass das Schema halb migriert ist und eine Tag-Query über beide rundheraus mit 468 scheitern kann. Eine tagsTable neben einem alten events liest sich genauso — bei jedem Öffnen des Stores, bis events umgestellt ist.

Prüfe vor der Migration auf Schaden, solange GROUP BY noch die faltende Kollation benutzt:

SELECT MIN(persistence_id) AS sample,
COUNT(DISTINCT persistence_id COLLATE Latin1_General_100_BIN2) AS spellings
FROM events
GROUP BY persistence_id
HAVING COUNT(DISTINCT persistence_id COLLATE Latin1_General_100_BIN2) > 1;

Jede Zeile bedeutet, dass sich zwei Ids bereits einen Stream teilen. Die Migration trennt sie wieder, und jeder Hälfte fehlen dann die Events der anderen — diese Actors scheitern beim Recovery also laut mit JournalIntegrityError (eine Lücke in der Sequenz), statt stillschweigend eine verschmolzene Historie auszuliefern. Das ist das bessere Scheitern, aber es bleibt ein Scheitern: entscheide vor der Migration, was diese Streams sein sollen, nicht danach.

  • Journal-Append liest den aktuellen Head und fügt innerhalb einer Transaktion ein; das expectedSeq des Callers wird gegen diesen Head geprüft. Ein konkurrierender Writer, der sich dazwischenschiebt, verletzt den Primary Key, und SQL-Server-Fehler 2627 (bzw. 2601 bei einem Unique-Index) wird als Backstop in einen JournalConcurrencyError übersetzt.
  • Durable-State-CAS läuft über die revision-Spalte: ein Create (expectedRevision === 0) ist ein einfaches INSERT, eine Kollision kommt also als Fehler 2627 an; ein Update ist UPDATE … WHERE revision = expected, wo null betroffene Zeilen bedeuten, dass die gespeicherte Revision abgewichen ist. In beiden Fällen wird die aktuelle Revision für den DurableStateConcurrencyError zurückgelesen.
  • Upserts nutzen MERGE … WITH (HOLDLOCK). Ohne diesen Hint können zwei konkurrierende MERGEs beide den NOT MATCHED-Zweig nehmen, und einer scheitert am Primary Key.
  • PostgreSQL — das andere relationale Backend, mit reicherem Upsert-Vokabular.
  • MariaDB — das Geschwister aus der MySQL-Familie.
  • Durable State — die State-orientierte Alternative zum Event-Sourcing.
  • Snapshots — begrenzt den Recovery-Scan.