Ein Blog

Posts mit Tag "sqlite"

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.

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.

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.

Node.js 22.4.0 ist da und hat die Web Storage API hinter einem Flag. Bei Node kann man also jetzt localStorage und sessionStorage benutzen.

Ich habe ein bisschen damit gespielt.

Der sessionStorage ist fĂĽr eine Programmlaufzeit gĂĽltig. Ist also nach einem Neustart weg. localStorage geht auch ĂĽber Neustarts hinweg. DafĂĽr muss man aber eine explizite Datei angeben: node --localstorage-file foo. Die Datei ist einfach eine SQLIte-Datenbank (wie die anderen Browser das intern auch machen):

$ echo 'localStorage.setItem("hallo", "welt")' | node --experimental-webstorage --localstorage-file foo

$ sqlite3 foo 'select * from nodejs_webstorage'
key    value
-----  -----
hallo  welt

Ist also eine super Alternative fĂĽr Key-Value-Storage, wenn man nicht extra SQLite installieren will.

Storage Events scheinen (noch?) nicht zu funktionieren. Da wär auch die Frage, ob die bei localStorage nur innerhalb des selben Prozesses funktionieren, oder ob alle Node-Instanzen da kommunizieren, wenn sie einen Wert in dieselbe Datenbank schreiben.

Bun kann mittlerweile nicht nur Rust und sonst irgendwie alles importieren, sondern auch SQLite-Datenbanken:

import db from './my.db' with { type: "sqlite" };

const { id } = db
  .query("SELECT id FROM users LIMIT 1")
  .get();

console.log(id); // 1

Man kann mit Bun seine Anwendung ja auch in eine einzige Binary bundlen. Wenn man das macht beim obigen, muss beim AusfĂĽhren die DB im aktuellen Verzeichnis liegen. Man kann die DB aber auch in dei Binary embedden:

import db from './my.db'
          with {
            type: "sqlite",
            // Embed the database into the executable
            embed: "true"
          };

const { id } = db
  .query("SELECT id FROM users LIMIT 1")
  .get();

console.log(id); // 1

Ob die DB da aber nur im Readonly-Modus geöffnet wird, wird im Blog nicht beschrieben. Ich gehe mla davon aus.

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.

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.

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.

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.