Subject Re: [IB-Architect] Disk Bandwidth was License Question
Author Jan Mikkelsen
>From: "Claudio Valderrama C." <cvalde@...>
>Just curious about:
> What's the database engine product that puts the database objects directly
>into filesystem files?

DB2 System Managed Storage tablespaces get their name because the storage is
managed by the operating system. The tablespace consists of one or more
containers, where each container is a directory in a filesystem. Database
objects are put into files: For tables, there is one file per container.
Multiple containers give you striping.

Blobs are different, the blobs in a given tablespace will share a file.

DB2 also has Database Managed Storage, where the behaviour is more as you
expect. Space allocation is handled by the database within containers sized
and allocated by the administrator. A DB2 filesystem of sorts is built
directly on top of raw devices or files in the filesystem. Many database
objects can live in a single file, but setting it up is more work.

Informix Standard Engine (SE) also stores tables as operating system files,
it also has one file per index on the table. Informix SE is targeted at
application vendors for embedding into applications. Informix Online (or
whatever they have renamed/extended it to) is quite a different system.

A large part of the motivation for developing your own "filesystem" has been
the terrible filesystems provided by Unix vendors. While things are better
now, I have terrible memories of fixing up filesystems so that information
could be extracted after fsck surrendered.

On systems with reliable (and often more functional) filesystems databases
will let the operating system do more of the work. I have used products on
VMS that use RMS for indexing, for example. The guarantees provided by
NTFS (and other journalled filesystems) are good, and on NT you can bypass
the cache manager entirely to get file access with similar performance to a
raw device.

You can get higher performance by getting the filesystem out of the way
because the database knows a lot about how it will be using the data.
However, if you just implement the database filesystem on top of a native
filesystem file, you have two levels of page allocation, and it gets harder
to relate pages back to the order they appear on the disk. I don't know how
big an issue internal fragmentation is in large Interbase databases: I
don't run any.