DEV Community: Peter Teoh

Difference between filesystem and database at the low level

Peter Teoh — Wed, 20 Aug 2025 08:17:48 +0000

"At low level" here means at the CPU and storage devices' block level.

Filesystems and databases are more similar than people think: both are storage managers that try to provide consistency, durability, and concurrency over bytes/records. Below we described how database' ACID properties (Atomicity, Consistency, Isolation and Durability) mapped to filesystem internals.

1. Atomicity

Database view: A transaction is “all or nothing.” Either all SQL operations commit, or none.
Filesystem equivalent:
- rename(2) in POSIX is atomic: the new filename is guaranteed to either point to the new inode or the old one, never half-written.
- Journaling filesystems (ext4, NTFS, XFS, btrfs) implement write-ahead logs or copy-on-write (COW). Example:
- ext4’s fs/jbd2/ journaling code logs metadata blocks first, then marks them committed.
- If crash occurs, replay ensures either the old inode/blocks are visible or the fully new ones—never a mix.
- Code path: in Linux ext4, see fs/ext4/namei.c: ext4_rename() → calls journaling routines in [fs/jbd2/transaction.c] for atomic commit.

2. Consistency

Database view: A transaction moves the DB from one valid state to another (constraints preserved).
Filesystem equivalent:
- Journaling or COW ensures metadata integrity: block allocation bitmaps, inodes, directory entries are always in a self-consistent state after crash recovery.
- Example: ext4 journals metadata operations in struct handle_s (see fs/jbd2/transaction.c) and replays them fully or not at all.
- Constraints in FS: free block counters match actual free blocks, no directory entry points to garbage, reference counts are accurate. Similar to DB enforcing primary key/foreign key rules.

3. Isolation

Database view: Concurrent transactions don’t interfere (enforced by locks, MVCC).
Filesystem equivalent:
- Locks: VFS provides inode-level locks (struct inode->i_rwsem, struct file_lock) to serialize writers and coordinate readers.
- Concurrent isolation: A file write + rename from one process is isolated from another process reading—Linux uses lock ordering in fs/read_write.c and journaling barriers.
- Ext4’s journal transaction handles are per-thread, isolating concurrent FS operations until commit.
- Isolation is weaker than DB MVCC: FS usually provides serializability for metadata but not full snapshot isolation for data blocks. (e.g., readers can see partially written data unless O_DIRECT or O_SYNC is used).

4. Durability

Database view: Once commit is acknowledged, data survives power loss.
Filesystem equivalent:
- Journaling (ext4/NTFS) or COW (btrfs, ZFS) ensures committed changes are persisted.
- In Linux ext4: jbd2_journal_commit_transaction() flushes journal blocks with blkdev_issue_flush() before reporting success.
- ZFS and btrfs use copy-on-write B-trees: old blocks stay untouched until new blocks + metadata are fsync’d. After crash, replay ensures new committed tree root is used.
- Applications rely on fsync(2) or fdatasync(2) to push buffers to disk—similar to DB COMMIT.

5. Mapping Table

ACID Property	Database	Filesystem Equivalent	Source Code (Linux/Ext4)
Atomicity	Transaction commit/rollback	`rename(2)`, journaling of inode/dir updates	`fs/ext4/namei.c:ext4_rename()`
Consistency	Constraints preserved	Journaling replays to keep block/inode maps valid	`fs/jbd2/transaction.c`
Isolation	Locks/MVCC	Inode/file locks, per-handle journaling isolation	`fs/inode.c`, `include/linux/fs.h`
Durability	WAL + fsync	Journal flush (`jbd2_journal_commit_transaction`) or COW flush	`fs/jbd2/commit.c`

6. Key Difference

Databases implement logical consistency (foreign keys, uniqueness).
Filesystems implement structural consistency (inodes, block bitmaps).
DB durability guarantees apply once commit returns, FS durability only applies once app calls fsync. Many apps forget fsync—leading to “committed but lost” anomalies.

Database ACID properties maps fairly well onto modern journaling or COW filesystems. Filesystem is a weaker transactional database specialized for file/inode structures. The kernel code shows the same primitives: logging, locking, atomic renames, and recovery replays.

New ChatGPT creation: wavy lines.

Peter Teoh — Fri, 06 Dec 2024 02:41:35 +0000

My latest creation via ChatGPT:

https://tthtlc.github.io/wavylines2.html

https://tthtlc.github.io/wavylines.html

Drawing lines on the circle

Peter Teoh — Wed, 04 Dec 2024 04:37:41 +0000

Take your imagination to the next level so so many variations:

https://hackgptdeveloper.github.io/2024/12/04/heart5.html

Lines joing two curves

Peter Teoh — Tue, 03 Dec 2024 01:12:14 +0000

Here are lines joining two curves in space:

https://hackgptdeveloper.github.io/2024/12/03/flower-in-motion-v2.html

https://hackgptdeveloper.github.io/2024/12/02/flower-in-motion.html

Another new (generalized) formula for graphics

Peter Teoh — Tue, 03 Dec 2024 00:37:23 +0000

Have fun playing with the new graphics:

https://hackgptdeveloper.github.io/2024/12/02/hypotrochoid-v4-explore.html

Great fun playing with hypotrochoid

Peter Teoh — Sun, 01 Dec 2024 16:09:26 +0000

Introducing a simple formula for experimentation:

x = (R - r) * Math.cos(f1*t) * (1 + Math.cos(f2*t)) + d * Math.cos(((R - r) / r) * t);

y = (R - r) * Math.sin(f1*t) * (1 + Math.cos(f2*t)) - d * Math.sin(((R - r) / r) * t);

where R, r, d, f1, f2 are different tunable parameter. The path of (x,y) as t varies will generate the graphics as shown in the following writeup:

https://hackgptdeveloper.github.io/2024/12/01/hypotrochoid-v3-explore.html

For example:

two new creation for you today

Peter Teoh — Fri, 29 Nov 2024 03:45:55 +0000

First is this:

https://hackgptdeveloper.github.io/2024/11/28/simple-petal-line.html

Next creation is a slight modification:

https://hackgptdeveloper.github.io/2024/11/28/simple-petal-line-color.html

Hypotrochoid adding to hypotrochoid

Peter Teoh — Wed, 06 Nov 2024 05:39:58 +0000

Adding hypotrochoid to hypotrochoid you get other variations:

https://tthtlc.github.io/double_hypotrochoid_explore.html

and this:

Now start adding epicycloid to simple sine waves projected from polar coordinates to the cartesian coordinates:

https://tthtlc.github.io/petal_add_epicycloid_explore.html

and this:

Epicycloid adding to Epicycloid

Peter Teoh — Wed, 06 Nov 2024 02:39:21 +0000

Attempting to draw an epicycloid here:

https://en.wikipedia.org/wiki/Epicycloid

I get:

https://tthtlc.github.io/epicycloid_explore_savepng.html
(R=160, r=40)

Now what happened if you combine this R,r=(160,40) with another epicyloid by adding them together?

The result is amazing:

https://tthtlc.github.io/epicycloid_add_epicycloid_explore.html

The formula used:

x = (200) * Math.cos(t) - 96 * Math.cos(5 * t)) + (R + r) * Math.cos(t) - d * Math.cos((R + r) / r * t);
y = (200) * Math.sin(t) - 96 * Math.sin(5 * t) + (R + r) * Math.sin(t) - d * Math.sin((R + r) / r * t);

Direct addition of two hyptotrochoid

Peter Teoh — Tue, 22 Oct 2024 05:56:31 +0000

Another day of exploration with Hyptotrochoid: what happen if you add two hyptotrochoid on top of another?

You get this - and you can also change all the parameters yourself to start exploring:

https://tthtlc.github.io/double_hypotrochoid_explore.html

and this:

and you start changing the color as well. Start exploring!!!

Mathematical art from Vortex parametric equation

Peter Teoh — Fri, 18 Oct 2024 02:21:21 +0000

With some inspiration from Pinterest (I lossed the original link already) I implemented this Javascript that draw the following parametric curves. And to my surprise, every single one values of the parameters (aaaa,bbbb,cccc) generate a different design:

function x(t) {
return Math.cos(t)+1/3*(Math.cos(aaaa*t)+Math.sin(bbbb*t));
}
function y(t) {
return Math.sin(t)+1/3*(Math.sin(aaaa*t)+Math.cos((bbbb-cccc)*t));
}

https://tthtlc.github.io/vortex_explore.html

and here are the different design:

My First Post: Hello Everyone!!!

Peter Teoh — Sat, 05 Oct 2024 03:42:37 +0000

Hello everyone!

As my first post, I would like to introduce everyone to the world of symmetry and beauty in mathematically created art.

First I got my motivation from Pinterest:

So I asked myself is it possible to create it with mathematical formula, perhaps just using compass and rulers, or just combining sinusoidal curves, or using polar coordinates (like those of drawing hypotrochoid etc).

There are hundreds of creations here, and it is still a work in progress.

But enjoy and provide feedback if possible.

http://www.artdeveloper.art/

which is mirrored in:

https://tthtlc.github.io/

and I do provide writeup on how the drawings can be achieved here:

https://tthtlc.wordpress.com/