Ein Blog

Posts mit Tag "db"

Vor ein paar Jahren hatte ich mal ein Experiment. Da habe ich SQL zur Compile-Time über TypeScript-Typen geparst und das Anttwortschema davon abgeleitet. Das lief komplett ohne externes Tooling und geht ohne änderungen am Buildprozess damit auch in JS-Anwendungen. Dadurch hat es auch keinen Runtime-Overhead. Hatte schon ein paar Vorteile. Die Nachteile sind: Das SQL zu parsen ist sehr aufwändig. Alleine das Whitespace-Handling richtig zu machen, ist super schwer. Dazu kommt, dass TS in den Typableitungen eine Begrenzung in der Rekursionstiefe hat. Zwar sind TS-Typen quasi eine funktionale Programmiersprache, aber eine sehr umständliche.

Parallel dazu gab es bei TypeScript immer den Wunsch, sowas wie F# Type-Provider zu bauen. Das hat man ne lange Zeit als Out-Of-Scope angesehen, besonders, wenn da noch Codegen involviert ist.

Jetzt gibt es in TS 7.1 aber etwas, was quasi genau das ist: Content Mappers. Damit kann man fĂĽr bestimmte Imports definieren, dass ein externes Programm invoked wird, welches dann einen Code zurĂĽckgibt, der fĂĽr Typinferenz verwendet werden kann.

Das hat jetzt der Macher von Zod genommen und etwas fĂĽr SQL gebaut. Der Vorteil: Das ist auch komplett zur Build-Time. Es verbindet sich auch direkt mit der Datenbank und checkt die Query direkt gegen die native Datenbank, also die Ergebnisse sind garantiert richtig. Auch verschiedene SQL-Dialekte werden damit ordentlich gehandlet. Zwei nachteile: Jede Query muss in eine eigene Datei. Und man kann deshalb auch keine Querys dynamisch zusammenbauen, wie z. B: bei Kysely.

Postgres 19 hat ein paar convenience-features und jetzt Support fĂĽr Graphen auf bestehenden Tabellen:

CREATE PROPERTY GRAPH store_graph
VERTEX TABLES (
    customers LABEL customer,
    orders LABEL "order"
)
EDGE TABLES (
    customer_orders 
        SOURCE customers 
        DESTINATION orders 
        LABEL placed_order
);

Wieder mal ein Post ĂĽber Job-Queues in Postgres. Dieses mal von den Planetscale-Leuten: Keeping a Postgres queue healthy.

Wie man eine Message-Queue in Postgres baut, wenn man low-volume (sprich: nicht millionen Nachrichten pro Sekunde) unterwegs ist, hab ich ja schon häufiger hier verlinkt.

Hier nochmal mit dem “Dead Letter Queue”-Pattern: Using PostgreSQL as a Dead Letter Queue for Event-Driven Systems.

Warum benutzen die ganzen Datenbanken eigentlich kein memory-mapped-io fĂĽr den Zugriff auf ihre Stammdateien? mmapping ist doch fĂĽr vieles deutlich schneller, als immer ĂĽber Syscalls zu gehen.

Hier wird es beleuchtet: Are You Sure You Want to Use MMAP in Your Database Management System?

Hatte es glaub ich schon ein paar Mal hier, dass man mit Postgres eine simple Task-Queue machen kann. Oder, dass man mit unlogged Tables einen einfachen Cache bauen kann. Das will man ggf., wenn man die Infrastruktur schmal halten will. Irgendwann braucht man dann oft natürlich doch eine “richtige” Lösung. Bis dahin, hier noch ein Post aus der Richtung: Kafka is fast — I’ll use Postgres

Build Your Own Database. Am Ende steht ein LSM-Tree!

TIL sqlite3_set_authorizer. Damit kann man einen Callback definieren, den SQLite aufruft, wenn eine Query auf eine bestimmte Datenbank/Tabelle/Spalte zugreifen möchte.

Gefunden, weil node:sqlite das jetzt kann:

import { DatabaseSync, constants } from 'node:sqlite';
const db = new DatabaseSync(':memory:');

// Set up an authorizer that denies all table creation
db.setAuthorizer((actionCode) => {
  if (actionCode === constants.SQLITE_CREATE_TABLE) {
    return constants.SQLITE_DENY;
  }
  return constants.SQLITE_OK;
});

// This will work
db.prepare('SELECT 1').get();

// This will throw an error due to authorization denial
try {
  db.exec('CREATE TABLE blocked (id INTEGER)');
} catch (err) {
  console.log('Operation blocked:', err.message);
}

Node.js hat ja schon SQLite eingebaut bekommen. In der neuen Node.js 24.9 gibt es dafür jetzt eine Erweiterung. Die API ist ähnlich zu der von Bun oder den tagged-template-strings, die ich mal als PoC statisch typisiert habe.

Aussehen tut das so:

import { DatabaseSync } from 'node:sqlite';

const db = new DatabaseSync(':memory:');
const sql = db.createSQLTagStore();

db.exec('CREATE TABLE users (id INT, name TEXT)');

// Using the 'run' method to insert data.
// The tagged literal is used to identify the prepared statement.
sql.run`INSERT INTO users VALUES (1, 'Alice')`;
sql.run`INSERT INTO users VALUES (2, 'Bob')`;

// Using the 'get' method to retrieve a single row.
const id = 1;
const user = sql.get`SELECT * FROM users WHERE id = ${id}`;
console.log(user); // { id: 1, name: 'Alice' }

// Using the 'all' method to retrieve all rows.
const allUsers = sql.all`SELECT * FROM users ORDER BY id`;
console.log(allUsers);
// [
//   { id: 1, name: 'Alice' },
//   { id: 2, name: 'Bob' }
// ]

Die Querys werden intern prepared und in einem LRU-Cache abgelegt. In den Docs steht leider nicht, wie man Arrays oder Sub-Querys ĂĽbergibt. Das wird sicher bald bei den Typen nachgereicht.

Postgres 18 ist da. Neu sind: Async IO, virtual generated columns, uuidv7(), OLD/NEW bei RETURNING und noch ein paar andere Sachen.

Postgres hat ja LISTEN/NOTIFY als Pub/Sub fĂĽr Menschen, die sich fĂĽr ein kleines Feature kein Redis hinstellen wollen.

Damit gibt’s auf großem Scale ein Problem: Wenn NOTIFY in einer Transaktion ausgeführt wird, lockt es die gesamte Datenbank.

Die Orange Seite hat noch ein paar Tipps, was man stattdessen benutzen kann.

Tracking SQLite Database Changes in Git. Hier gibt es noch einen weiteren Trick, der nicht die SQLite-DB als Blob speichert, sondern als Plain-Text.

Manchmal hat man in Datenbanken ein paar Felder, die Ranges darstellen und verschiedene Zeilen sich in den Ranges jeweils nicht ĂĽershcneiden dĂĽrfen, z. B. bei Reservierungen. Postgres hat da was fĂĽr, um auf Schema-Ebene zu garantieren, dass man da keine Ăśberlappungen bekommt: Time Ranges without Overlapping.

Grundlage dafĂĽr sind Range Types in Postgres.

Bun hat neulich ja einen S3-Client eingebaut (ich habe übrigens auch gerade einen veröffentlicht). Jetzt haben sie auch noch einen Redis-Client dazu gelegt.

Diese Woche habe ich das Konzept von “German Strings” kennengelernt. Das sind immutable Strings, die mit einer erweiterten Variante der Short-String-Optimization gehalten werden. Sie enthalten noch in den 16 Bytes den Präfix vom String. Damit kann man viele String-Operationen machen, ohne den Pointer auf die Daten zu dereferenzieren. Und ist besser für Lokalität bzw. Caching.

Der Name kommt wohl daher, dass in einem Paper von einem deutschen Stand und einer der ersten Implementoren zu faul war, den tatsächlichen Autor zu nennen.

Hier hat sie jemand in Rust implementiert, um einen Punkt zu beweisen. Dort wird auch der Autor vom Paper genannt: Umbra.

Node.js kann jetzt SQLite. FĂĽr die WebStorage-API neulich haben sie es ja schon eingebaut. Jetzt exposen sie auch die interne API nach auĂźen.

import { DatabaseSync } from 'node:sqlite';
const database = new DatabaseSync(':memory:');

// Execute SQL statements from strings.
database.exec(`
  CREATE TABLE data(
    key INTEGER PRIMARY KEY,
    value TEXT
  ) STRICT
`);
// Create a prepared statement to insert data into the database.
const insert = database.prepare('INSERT INTO data (key, value) VALUES (?, ?)');
// Execute the prepared statement with bound values.
insert.run(1, 'hello');
insert.run(2, 'world');

Sieht nur semi-kompatible mit dem SQLite von Bun aus.

Postgres kann Indizes mit Bloom-Filter.

Use-Case:

In the case of an index access method, it allows fast exclusion of non-matching tuples via signatures whose size is determined at index creation. […] This type of index is most useful when a table has many attributes and queries test arbitrary combinations of them. A traditional btree index is faster than a bloom index, but it can require many btree indexes to support all possible queries where one needs only a single bloom index. Note however that bloom indexes only support equality queries, whereas btree indexes can also perform inequality and range searches.

Es gibt in SQL ein SELECT FOR UPDATE (MariaDB, Postgres), was man in Transaktionen benutzen kann, um schon frühzeitig zu sagen, dass man die entsprechenden Zeilen updaten wird, damit sie schon direkt gelockt werden können. Dadurch kann verhindert werden, dass Transaktionen unnötig neu versucht werden müssen.

Man kann sich mit einer SQL-DB ja eine Task-/Message-Queue für Arme bauen. Das ist besonders dann eine mögliche Lösung, wenn man noch kein ein Queuing-System hat oder die Anzahl an Messages pro Sekunde überschaubar ist. In diesem Fall kann man nicht nur SELECT FOR UPDATE verwenden, sondern auch zusätzlich noch SKIP LOCKED[hinweis]. Durch das SELECT FOR UPDATE wird ja nicht verhindert, dass sich ein anderer Worker die Nachricht zusätzlich noch holt. Mit SELECT FOR UPDATE SKIP LOCKED kann man die Zeilen überspringen, die gerade in einer Transaktion sind.

SQL 2023 ist da. Der Standard kostet natürlich Geld. Hier gibt es eine Übersicht über die neuen Features. Interessant sind “Property Graph Queries”. Beispiel aus dem verlinkten Post:

CREATE TABLE person (...);
CREATE TABLE company (...);
CREATE TABLE ownerof (...);
CREATE TABLE transaction (...);
CREATE TABLE account (...);

CREATE PROPERTY GRAPH financial_transactions
    VERTEX TABLES (person, company, account)
    EDGE TABLES (ownerof, transaction);

SELECT owner_name,
       SUM(amount) AS total_transacted
FROM financial_transactions GRAPH_TABLE (
  MATCH (p:person WHERE p.name = 'Alice')
        -[:ownerof]-> (:account)
        -[t:transaction]- (:account)
        <-[:ownerof]- (owner:person|company)
  COLUMNS (owner.name AS owner_name, t.amount AS amount)
) AS ft
GROUP BY owner_name;

Ein paar Footguns bei Postgres. Hier ein Rechner fĂĽr ein paar Postgres-Parameter.

Postres-Wiki-Seite zum Thema Don’t do this.

Auf der orangen Seite gibt es noch mehr.

Situation: Man hat eine Tabelle mit vielen Einträgen und möchte aber einen großen Teil (z. B. alte Einträge) löschen. Problem: Ein einfaches DELETE FROM logs WHERE created_at < '2023-04-01' kann sehr lange dauern und damit das Schreiben in die Tabelle blockieren. Ein Index hilft da leider nur bedingt.

Eine mögliche Lösung: Partitionieren der Tabelle. Indem man die Tabelle nach dem Löschkriterium partitioniert, kann man das Droppen von Einträgen deutlich beschleunigen.

Beispiel aus Postgres dazu:

CREATE TABLE logs (
  -- more columns...
  created_at timestamptz NOT NULL
) PARTITION BY RANGE (created_at);

CREATE TABLE logs_2023_01 PARTITION OF logs FOR VALUES
  FROM ('2023-01-01 00:00:00+00') TO ('2023-01-31 23:59:59+00');
CREATE TABLE logs_2023_02 PARTITION OF logs FOR VALUES
  FROM ('2023-02-01 00:00:00+00') TO ('2023-02-28 23:59:59+00');
CREATE TABLE logs_2023_03 PARTITION OF logs FOR VALUES
  FROM ('2023-03-01 00:00:00+00') TO ('2023-03-31 23:59:59+00');
CREATE TABLE logs_2023_04 PARTITION OF logs FOR VALUES
  FROM ('2023-04-01 00:00:00+00') TO ('2023-04-30 23:59:59+00');

ALTER TABLE logs DETACH PARTITION logs_2023_01 CONCURRENTLY;

DROP TABLE logs_2023_01;

Dieses Beispiel hab ich aus SQL-for-Devs übernommen. Dort gibt’s auch noch eine detailliertere Beschreibung sowie ein MySQL-Beispiel, wer mehr wissen möchte.

SQLite hat aktuell einen concurrent writer. Aktuell arbeiten sie an einer Erweiterung des DB-Formats, womit diese Limitierung entfällt: HC-tree Der Multi-Process-Support war deshalb immer etwas hakelig. Das zu verbessern ist jetzt eine Designziel.

Hier sind noch ein paar Benchmarks.

Wir hatten ja schon SQLite nach WASM kompiliert im Browser. Jetzt gibt es auch Postgres im Browser.

Heute lernte ich: Die SQLite-CLI kann ZIP-Dateien öffnen. Der Inhalt ist dann in Form einer virtuellen Tabelle sichtbar.

Weiter unten wird auch ein Command vorgestellt, das einem Indexe empfiehlt.

Cloudflare hat fĂĽr ihre Workers jetzt eine Datenbank: D1.

Was mich freut, ist, dass die auf SQLite basiert. Das zeigt, wie ausgewachsen SQLite ist.

In dem Beispiel ihres Use-Cases sieht man, dass sie Raw-SQL für die DB-Abfragen benutzen. Für genau diesen Use-Case baue ich gerade an einer prototypischen Lösung: sequelts. Die Idee: Man nutzt die Turingvollständigkeit vom TS-Typsystem, um SQL-Querys auf Typebene zu parsen und den Rückgabetypen zu inferieren. Bald wird es als proof-of-concept noch mit sowas wie sql-template-strings kombiniert. Wenn man das hat, hat man die Richtung für’s Abfragen von Daten typsicher (und mit erzwungenen Prepared Statements auch “secure”). Danach schaue ich weiter, in wie weit man sicherstellen kann, dass es keine Veränderungen an den Daten gibt, die nicht zulässig sind. Das steht aber noch in den Sternen.

MeiliSearch 0.26 ist da.

Ich schreibe das eigentlich nur, weil ich das ein cooles Projekt finde. Die neue Version hat tenant tokens.

Schaut Euch das mal an.

Ich hatte schon im Blog: SQLite im Browser mit HTTP-Range-Requests, sodass man in einigen Use-Cases ein Backend wegrationalisieren und durch eine statisch gehostete SQLite-Datei ersetzen kann.

Später kam dann darauf basierend ein statisch gehostetes Wikipedia mit Suchfunktion[hinweis].

Das nächste Level ist jetzt die oben verlinkte Seite: Die SQLite-Datei nicht per HTTP servieren, sondern mit BitTorrent. Was viele nicht wissen: Torrents gehen mittlerweile auch im Browser, über WebRTC. libtorrent unterstützt das auch, damit auch die bekannten Clients wie Deluge.

Was macht man mit so einer dezentralen SQLite-DB? Die Demo ist jedenfalls eine Torrent-Suchmaschine, die Magnet-Links zurĂĽckgibt.

Ich bin von dieser Kreativität beeindruckt. Eingedampft hat man hier eine HTML-Seite mit ein bisschen JavaScript, die man statisch hosten kann. Bekommen tut man eine Torrent-Suchmaschine.

SQLite 3.38.0 ist da. Neu ist u. a. der JSON-Support, der jetzt per Default eingeschaltet ist. Dazu kamen auch noch JSON-Operatoren, die mit Postgres kompatibel sind.

Ein cooles SQLite fiddle. Läuft komplett im Browser. Kann auch statisch gehostete SQLite-DBs als Quelle nehmen.

Heutiger SQLite-Post: SQLAR, ein komprimiertes Archivformat, was gleichzeitig eine SQLite-Datenbank ist. Idee: Es ist eine normale SQLite-DB, die zusätzlich diese Tabelle hat:

CREATE TABLE sqlar(
    name TEXT PRIMARY KEY,  -- name of the file
    mode INT,               -- access permissions
    mtime INT,              -- last modification time
    sz INT,                 -- original file size
    data BLOB               -- compressed content
);

Rest dürfte selbsterklärend sein. Die Vorteile sind die, die man bei normalen SQLite auch hat: Transaktionen, man kann SQL-Querys auf Dateinamen/Attribute machen, die Datei ist inkrementell updatebar etc.

Wo wir gerade bei Postgres waren: Postgres hat einen riesen-Haufen vordefinierter Typen: https://www.postgresql.org/docs/9.5/datatype.html

U. A. einen Typen fĂĽr IP-Adresse und einen fĂĽr IP-Netze. AuĂźerdem kann eine Tabelle auch Array-Spalten enthalten. AuĂźerdem auch noch Enums und geometrische Typen (Punkte, Pfade, etc).

Aktuell mache ich ein bisschen Postgres und muss irgendwo festhalten, was mir so fĂĽr Dinge auffallen, die ich aus MariaDB und SQLite nicht so kenne.

Heute: Domains

Man kann in Postgres eigene Datentypen anlegen und diese auch mit CHECKs versehen:

CREATE DOMAIN percentage
AS INTEGER
CHECK (VALUE BETWEEN 0 AND 100) NOT NULL;

Und sie dann ganz normal verwenden:

CREATE TABLE test (
    -- ...
    amount_finished percentage,
    -- ...
);

Es gibt auch noch CREATE TYPE. Der Unterschied wird hier erklärt.

Falls Ihr gerade an einem Backend schreibt und ĂĽberlegt, ob Ihr neben Euer Postgres noch eine Message-Queue stellt (z. B. Redis): Postgres hat LISTEN/NOTIFY[hinweis] und kann damit auch als Message-Broker verwendet werden.

Funktioniert auch in einem Trigger, sodass z. B. andere Clients mitbekommen können, wenn eine neue Zeile eingesetzt wurde.

Wo wir gerade bei Datenbanken waren - Ihr kennt sicher Discord. Heute stolperte ich ĂĽber einen Artikel der Discord-Leute aus dem Jahr 2017, wo sie ihre Migration von MongoDB auf Cassandra beschreiben. Also mit technischen Requirements und BegrĂĽndungen etc., wie man das machen sollte. Der Artikel beschreibt ganz gut und geht auch darauf ein, was man bei Cassandra beachten sollte.

Wer bei Cassandra an “Ressourcenfressende Java-Datenbank” denkt, mag vielleicht nicht ganz falsch liegen. 2020 migrierten sie dann auf ScyllaDB, einem Cassandra-kompatiblen Drop-in-Replacement, geschrieben in C++.

Ihr kennt sicher Elasticsearch. Wenn Ihr es nicht selbst schon eingesetzt habt, kennt ihr es vielleicht, weil das gerne offen im Netz hängen gelassen wird oder weil Amazon das aus lizenztechnischen Gründen geforkt hat.

Ist eine Datenbank, die spezialisiert auf Suche ist (ok, da hätte man drauf kommen können). Da es aber in Java geschrieben ist und auch schon ein bisschen existiert, ist es eher relativ dicke Software, die vieles kann und auch viel Ressourcen verbraucht, letztendlich auch wegen Java. Ich kenne Software-Stacks, in denen das zur Auswertung der Logs verwendet wird. Dort kommt es dann nicht selten vor, dass der Elasticsearch-Logging-Stack mehr Ressourcen verbraucht, als die eigentliche Anwendung.

Ich komme darauf, weil gerade Version 0.21.0 von MeiliSearch freigegeben wurde. Das ist auch eine Datenbank, die spezialisiert auf Suche ist, allerdings in Rust geschrieben (ja, ich weiß, “alles ist besser in Rust” ist ein alter Hut etc.).

Diese Software habe ich schon halb-produktiv verwendet und bin positiv beeindruckt. Sie ist recht einfach aufgebaut, die API ist super straight-forward, genau wie das Rechtesystem. Die Dokumentation ist m. E. n. super gut dafĂĽr, dass es Pre-1.0-Software ist. Deployen kann man das Ganze zur Not auch ohne Container, da das gesamte Teil eine einzige Binary ist, die man auch mit einem einfachen git clone und cargo build selbst bauen kann. Die API-Endpunkte sind dafĂĽr gebaut, dass man sie direkt von einem Web-Frontend aus ansprechen kann, ohne Backend-Logik dazwischen.

Vom Funktionsumfang ist das natürlich nicht mit einem Elasticsearch vergleichbar. Es ist ja auch noch Pre-1.0-Software. Die Use-Cases überschneiden sich wahrscheinlich auch nur teilweise, weil MeiliSearch aktuell primär für “Search-as-you-Type”-Sachen gemacht ist.

Neben Elasticsearch und MeiliSearch gibt es natĂĽrlich auch noch andere Alternativen. Was ich mit diesem Post auf jeden Fall sagen will: Es muss nicht immer Elasticsearch sein und die Alternativen kennen viele nicht.

Ihr erinnert Euch vielleicht an die eine Seite, die eine SQLite-Datei mit Range-Requests serviert hat, um dann Clientseitig SQL-Statements per HTTP darauf abzusetzen (Zugriff auf Offsets in der SQLite-Datei wurden auf Range-Requests gemappt).

Hier hat das jemand genommen und die gesamte Wikipedia in eine SQLite-Datei gepackt[hinweis]. Also mit Volltextsuche und ohne wirkliches Backend.

HN dazu

Cooler Talk vom SQLite-Erfinder über… SQLite. Er gibt ein bisschen an, ist aber IMHO ein guter Speaker, dem man gut zuhören kann.

Die heutige SQLite-News: SQLite hat eine Volltextsuche. War unter diesem Artikel verlinkt, der eine Elasticsearch-Instanz mit SQLite ersetzt hat.

SQLite ĂĽberrascht mich immer wieder.

Ich immer, mit meinem SQLite. Hier hat jemand etwas echt cooles gebaut: Eine SQLite-Datei, statisch gehostet. Der JS-Client kann an diese Anfragen schicken. Ein Wrapper um das Client-Dateisystem fragt Seiten erst an, wenn der SQLite-Client sie lesen will.

Warum ist das cool? Man kann damit eine komplett statisch gehostete Suchfunktion für statische Seiten bauen, bei dem die SQLite-DB bei jedem Page-Build frisch gebaut wird. Oder bequem Datensätze an den Client ausliefern, ohne ein Backend zu haben. Da gibt’s sicher noch einige Anwendungsfälle mehr!

Ich bin’s wieder mit meinem SQLite. Hier ein toller Post darüber, was SQLite alles out-of-the-box mitliefert. Einige Sachen erstaunen mich dann doch etwas (z. B. nativer JSON-Support und Perzentile) (HN-Thread dazu).

Ich bin ja ein groĂźer Fan von SQLite. Davon kam gerade Version 3.35.0 raus. Das ist fĂĽr mich ein richtig groĂźartiges Release. Kurzer Auszug:

  • Ein paar Mathe-Funktionen
  • ALTER TABLE DROP COLUMN (vorher musste man die Tabelle in eine neue kopieren)
  • RETURNING-Keyword fĂĽr schreibende Operationen (DELETE/INSERT/UPDATE), bei dem die entsprechende Zeile zurĂĽckgegeben wird
  • Materialized CTEs

Bis auf die Mathe-Funktionen sind das alles Game-Changer fĂĽr mich.