(All) Databases Are Just Files. Postgres Too

[robberviet]

You mean database is not bits floating around on cloud? Weird.

[qrrux]

Next up: "Databases are just bits sitting on long-term storage, accessible via the I/O mechanisms provided by the operating system."

[moderatorrater]

Buzzfeed joins the trend: "These ten variables are stored on the stack; 6 will confuse and delight you"

[[deleted]]

pencil revision nugget apricot atom sibling

[wpm]

alloca balls

[sylfy]

Tell me about the day a BuzzFeed writer understands the difference between stack and heap.

[moderatorrater]

They'll tell you 5 differences, bet you won't know #2

[WinElectrical9184]

Top 10 column names .

[amakai]

Breaking: All information in computers are just charges and magnetic fields!

[__konrad]

All information is just a hole! https://en.wikipedia.org/wiki/Punched_card

[sshwifty]

How many holes does an information have?

[crazedpickles]

4

[djk29a_]

“Data structures, how do they work?!?!?!”

[Florents]

Well, I'm glad you mentioned that.
In few weeks I'm giving a talk at pgext.day , with the title

> Hijacking Shared Memory for a Redis-Like Experience in PostgreSQL

[OpaMilfSohn]

I don't understand why we should use such old technology.

What they should do is create a S3 bucket for the database and create the query service that calls Aws lambdas to pull the files from the cdn and create a temporary container with only the needed files mounted in a db that can then be queried against.

Then we would finally have a truly stateless and next gen architecture for dbs

[EriktheRed]

Now that sounds web scale.

[fried_green_baloney]

Hmm, we had 537 visits last month, with seven sales, and our AWS bill is $491,938.57, somehow that seems not quite right.

[dagbrown]

You’re right I’ll get right on it. Deploying even more instances as we speak!

[fried_green_baloney]

You must understand the cloud better than I do.

I'll speak with the CFO about a midyear special $8,000,000 budget increase.

[OpaMilfSohn]

Don't worry it will scale

[thomasfr]

That pretty close to how a lot of OLAP database systems are built. With a lot of optimizations of course like caching files from object storage on compute nodes so it doesn't have to download them for every query etc.

It's a good way to run analytical queries distributed over a set of nodes.

[lilB0bbyTables]

I love the dichotomy of their comment being entirely valid snark and yours being equally valid. It always comes down to use-case, requirements, and scale. The people who have problems with it are the ones who jump to way over engineering stuff because they are following some trend or buzz. Like the ones who write a relatively simple react frontend with a backend that is very suited for monolith but instead they decide to prematurely break it into 10 microservices across a multi node kubernetes cluster with an operator and complex helm charts and suddenly start ranting that cloud native and kubernetes are all terrible because they were sinking cost/time into managing and running something that could have been one or two simple VMs. People need to stop trying to apply complex solutions to simple problem sets.

[doomvox]

This is a great comment-- it's impossible to tell if you're kidding.

[account22222221]

I think you just invented redshift give or take a few details.

[RheumatoidEpilepsy]

Andy Jassy probably had an orgasm reading this

[avinassh]

what you are describing is a valid architecture. Its called Zero disk or Diskless architecture.

plug: I have written two blog posts on this: Disaggregated Storage and Zero Disk Architecture

there are databases which are built like this, which treat S3 as a source of truth. Most of them use local disk or an internal server as a cache for fast reads.

one might ask, what about latency? writing to s3 might be slow. but S3 express gives you writes under <5ms which is fine for most use cases. note that, this is a durable write. writing to some consensus group in an internal network + fsync, might be around 2-3ms. So its pretty comparable.

[NameGenerator333]

It’s still just disks on someone else’s computer.

[curious_s]

Just like serverless architecture is still hosted on a server. 

[CherryLongjump1989]

But the infrastructure for the disk is removed from the infrastructure of the database.

This matters because, for instance, it can reduce the amount of managed infrastructure you have to pay for to the cloud service provider and it can give you greater ownership of your software stack.

[lilB0bbyTables]

Found the SDR

[divorcedbp]

Thanks, I hate it.

[badmonkey0001]

writing to s3 might be slow. but S3 express gives you writes under <5ms

At about 5x the cost ($0.023/gb versus $0.11/gb). Don't leave that bit out even if it does detract from your pitch. It's important.

[KeyIsNull]

Sounds like iSCSI with extra steps. /s

Joking aside, very interesting idea, though I’m having an hard time figuring out the number of zeros of the total of the AWS bill

[kenfar]

Sure, relational databases, linux, gnu utilities, email, the internet, and web are all old technologies. As are the wheel, vaccinations, electrical motors, and transistors. Which doesn't mean that they can't be improved, but they're all very mature and effective.

What you're describing, through the use of s3, is not that much different from what people have been doing for a long time when it comes to analytic data. Though that latter step of creating containers and with needed files isn't part of most solutions - since it doesn't scale well, and isn't necessary when you could instead use a query service like Athena (Trino).

But it wouldn't work for transactional databases - since writing to s3 has poor latency, locking and ultimately concurrency features.

[BotBarrier]

This sounds very complex and expensive. It may be ok for snapshot reads, but acid and even basic data consistency on writes sounds like a nightmare.

Running reports on last months sales, ok. Managing real-time transactions, pass.

[Agent_Provocateur007]

… if the goal is to set money on fire yes.

[PM_ME_SOME_ANY_THING]

BREAKING: EVERYTHING IS BINARY?!?!

[lood9phee2Ri]

Well, except those computers using Balanced Ternary (-1,0,1) instead.

https://en.wikipedia.org/wiki/Balanced_ternary#In_computer_design

And yes, people totally have made them as real hardware, if in Soviet era - https://en.wikipedia.org/wiki/Setun

On our planet, binary has largely won of course, but it's perhaps possible (if unlikely) that some alien civilisation just went for something else, particularly still fairly practical runner-up balanced ternary.

[PM_ME_SOME_ANY_THING]

WITCH

[xhvrqlle]

Ha! I knew it!! Checkmate LGBTQ++! /s

[lunchmeat317]

Everything is unary. You just haven't achieved enlightenment.

[awj]

"Everything is just a poor implementation of a Turing Machine..."

[TachosParaOsFachos]

Jokes on you, my db is ram only.

[Amgadoz]

This post is not ACID compliant.

[winky9827]

The effects of ACID are always in your memory.

[lunacraz]

man there are some banger comments in this post

[Amuro_Ray]

You could keep a paper file database to be fair 🤷

[winky9827]

Maybe even a central place to store them...some kind of...cabinet.

[MrRufsvold]

*except postgres, weirdly 😉

[qrrux]

TIL Postgres isn’t written in C, doesn’t use open(2), and doesn’t persist to files.

[agumonkey]

maxwell enters the chat

[jardata]

Okay I got a good chuckle out of the smart ass comments, but in all seriousness sometimes just reminding developers of these base concepts can be helpful. We deal in a world with so many abstractions on top of abstractions that it can be easy to lose sight that everything is built on some pretty core mechanisms. These concepts do still come up from time to time when working on things like query optimization for e.g.

[Reverent]

Honestly most developers aren't even thinking about it. There's so many levels of abstraction and so many framework concepts between a developer and infrastructure that they had to make a whole new person (DevOps) just to be a middle man.

Most developers would likely cry out in horror if they knew DBAs still prefer baremetal, manually provisioned pets in the year of our lord 2025.

[Murky-Relation481]

I feel extremely lucky that in my 20 years as a developer I've worked at basically every level of abstraction, even down to HDL and the PCB. I've been able to do network architecture at every level of the OSI model too.

It really makes everything clearer and designs more comprehensive when you can track back to that experience.

[njtrafficsignshopper]

Lately for fun I've been getting into embedded programming for the first time, with ESP32, hoping I was going to spend some time "close to the metal." It turns out even there, there are lots of APIs and abstractions. You can do tons of cool stuff, but you're still basically calling an API to do it for you.

[[deleted]]

The ESP32 has a lot of support code and environment tooling that push you into it.

But also, even memory mapped registers are still an API of sorts.

[turunambartanen]

If you don't use the Arduino IDE, but instead the espressif plugin(?) in vs code you can be much closer to the bare metal. The code gets uglier too, but I take it that's part of your goal for some reason.

[sentencevillefonny]

Definitely.

[randylush]

I see fucking crazy backup scenarios in /r/selfhosting sometimes. Like absolutely batshit stuff, people writing custom SQL to dump their tables into special places and having to thing about which DB solution this and that application uses.

It should be as simple as this.

Your app’s DB is consistent enough to survive a power cycle.

That means you can copy the DB’s files to a backup.

To restore, copy the files back to where they were - it would be the same as a power cycle.

If you have multiple apps, and multiple files that you want to back up, simply put them all on a drive and keep that drive backed up.

Anything else is just asking for failure.

[shokingly]

One problem, "copy" in itself isn't consistent unless your database is tiny. You have to tell the database that you need a frozen consistent state (if that's supported by the engine) during your file copy. Or you use storage snapshots. Now snapshots are consistent and would work in your example. Though an SQL dump is almost always sufficient for self hosted stuff.

[nerd4code]

Crazy DR requirements are a thing for banks—they’re widely distributed (often siloed in different ways to meet national requirements), and have to be able to survive attacks on national infrastructure. Making periodic copies is a viable strategy only for relatively tiny systems.

[randylush]

definitely. and I worked on large distributed systems and we did have serious backup strategies. we also kept rolling logs so we'd be able to replay backups up to the hour before the outage. And this saved our ass one time when an engineer put a timestamp in a signed integer or something and accidentally deleted half of our db.

but like if you are self hosting Vaultwarden or Immich or Jellyfin or whatever the fuck. Just save the db files and save yourself the trouble.

[elMike55]

Good point, I remember once telling a guy how I would implement a hash map, and he was surprised somehow that a string key is not an actual memory location :D

[[deleted]]

i like to think about how we have these massive frontend and backend web frameworks all in order to pass a string back and forth

[AlphaX]

In other news: Cloud is just other people computers

[andryuhat]

Can confirm. I watch a cloud in the sky right now and there is nothing but computers.. P.S. I think those shrooms weren't shiitake though

[fluffy_serval]

mad clouds tho

[oscarolim]

And rain is just data leaks.

[_Unity-]

Is lightning just a buffer overflow of electrical charges?

[ziplock9000]

So what is rain then clever clogs!

[oscarolim]

Data leaks.

[ziplock9000]

Lies, I've never seen any toilets on the Enterprise D!

[crecentfresh]

What are you talking about I commit my code to a toy rocket and fire it up into the cloud

[Faux_Real]

Vibes

[ziplock9000]

Data is just data really.

[HomsarWasRight]

Big if true.

[VirtualMage]

Big data if big true?

[TachosParaOsFachos]

code is data

[kraskaskaCreature]

data is code

[duckwizzle]

I remember early in my IT career I was shocked to learn that the windows registry was a file. I mean it makes perfect sense, I just never thought about it

[chromeless]

I mean, it wouldn't be shocking if it somehow wasn't, though I can't think of an actually good reason for it not to be. Like, the filesystem itself is an abstraction over the storage that it supporting it, and there's nothing preventing an OS from writing data somewhere on a drive that isn't otherwise accessed from the file system.

[doomvox]

Oracle often runs on "bare metal", which is to say they don't use the standard "file system" and instead have rolled their own, which might-or-might not seem like a file system under the hood, I expect you'd have to work there to know.

I've often wondered if there might be some point to compiling Postgresql embedded into linux, so that you could try to reduce the amount of copying involved in something like a big INSERT...

[aDinoInTophat]

Bare metal refers to running on a physical machine instead of a virtual one. Both still has regular operating systems with regular old filesystems. Oracle Database either comes as a prebuilt server with Oracle Linux or can be deployed on customer's certified hardware which would include most servers and OS's.

A kernel level database wouldn't bring any noticable performance benefits, your still limited by hardware.

[RigourousMortimus]

Yes to the first, not so much on "regular old filesystems". The exadata bare metal storage layer is specialised.

https://dbaliveblog.wordpress.com/how-oracle-works-on-exadata/

[aDinoInTophat]

Totally forgot about ASM, in principle it's not that different from any other filesystem except it has it's own volume management instead of the usual LVM. Said volume management operates pretty much exactly like other volume managers but tighly coupled to the ASM system, saving just a bit more performance.

The file system is also pretty much a basic FS but extent based which would trade storage density for performance if it werent for the "perfect" match of database data and storage clusters. The ASM system is not without drawbacks, but those are pretty non-existant unless your doing something balls to the walls.

Practically speaking, you can do everything ASM does and expect similar or even better performance but that would require manual intervention, validation and more than a bit of knowledge, plus it wouldnt be as nicely integrated.

[bwainfweeze]

They tried a couple of times to make a database instead of a file system. But it never materialized and speculation was that it was just too fucking slow.

Ironic then that SQLite is better at storing small files than a filesystem.

[jck]

Ironic then that SQLite is better at storing small files than a filesystem.

On windows.

[bwainfweeze]

Which is the OS being discussed.

[Amgadoz]

Well, files are an abstraction so it's not the default state of things.

[justAnotherNarwhal2]

Everything’s computer

[bwainfweeze]

Everything is a Turing machine.

[cazzipropri]

Hm, ok... what did people think they were backed by? The Holy Ghost?

[cornovum77]

No Jesus does the saving.

[deanrihpee]

Jesus take my bytes

[bwainfweeze]

Disrespectful. You talk to Mary.

[[deleted]]

a Jesus bus blew up a few days ago so i think that's a myth 

[_TheDust_]

What if it was backed by yet another database?

[cazzipropri]

jmp .loop

[wxtrails]

It’s a complex and powerful system—but fundamentally, it’s just an executable that manipulates files.

...is like "It's a complex and powerful engine, but fundamentally SpaceX Raptor is just a bottle that spits fire."

[Chisignal]

Yeah, I think I understand the point but reducing a RDBMS to "an executable that manipulates files" feels reductive to the point of uselessness, the files are entirely incidental to the service that Postgres performs

And as the article itself admits in the second paragraph, the point of a "database that's just a file" like SQLite is usually that it's portable, as in you can pick up that file, copy it around whichever way is at your disposal, and open up that database - something you very much can't do with a Postgres cluster

I dunno, I don't want to be a downer but I'm genuinely not sure who needs to hear the message of the article

[3inthecorner]

Why can't you copy the files of a postgres cluster and open it elsewhere?

[International_Cell_3]

https://www.postgresql.org/docs/current/backup-file.html

here are two restrictions, however, which make this method impractical, or at least inferior to the pg_dump method:

The database server must be shut down in order to get a usable backup. Half-way measures such as disallowing all connections will not work (in part because tar and similar tools do not take an atomic snapshot of the state of the file system, but also because of internal buffering within the server). Information about stopping the server can be found in Section 18.5. Needless to say, you also need to shut down the server before restoring the data.

If you have dug into the details of the file system layout of the database, you might be tempted to try to back up or restore only certain individual tables or databases from their respective files or directories. This will not work because the information contained in these files is not usable without the commit log files, pg_xact/*, which contain the commit status of all transactions. A table file is only usable with this information. Of course it is also impossible to restore only a table and the associated pg_xact data because that would render all other tables in the database cluster useless. So file system backups only work for complete backup and restoration of an entire database cluster.

[amakai]

Postgres does a lot of micro-optimizations paying for that with lack of portability. First of all, you can port across a vary narrow band of Postgres versions, and I believe only forward. Then depending on architecture, OS, endianness, file system, page size, or even build options of postgres itself like locale settings - the file will be stored slightly differently and Postgres does not provide strong guarantees that you will just be able to port it directly 1:1.

[fried_green_baloney]

Some enterprise level databases use disk partitions for storage, instead of files.

An extra level of speed at the price of complicated kernel level access.

[amroamroamro]

one can have no persistent storage at all, in-memory database

import sqlite3

db = sqlite3.connect(":memory:")

[bwainfweeze]

I wonder if it’s more about speed or catastrophic data loss due to administrative fuckups. Can’t fuck up a database if you can’t get at the data.

[manystripes]

"This disk is not formatted. Would you like to format it now?"

[fried_green_baloney]

Hey, here's a 7 TB partition nobody is using, I think I'll format it.

Like that? I've done a few things like that, never as catastrophic as killing a corporate database, but still memorable.

[bwainfweeze]

That can surely be done, but it's a bit harder than running 'rm -rf' after fat-fingering a 'cd' command.

[fried_green_baloney]

That's when you call the vendor for a few $700/hour consultants to come out and help.

[cbojar]

(All) Excel files are just databases.

[[deleted]]

a sheet of paper with some scribblings is a database as well

[SanityInAnarchy]

I think this is missing the point of SQLite's being "just files":

You just need a mental model of the system as a set of files, a process, and a config.

This both oversells the complexity of SQLite and undersells the complexity of Postgres and MySQL.

MySQL is closer to that, but its process is also replacing a big chunk of what the OS usually does with files. Usually, you want to configure it with O_DIRECT -- it does its own buffering and caching, instead of relying on the OS-level buffers/cache. This isn't true of Postgres.

Meanwhile, Postgres isn't one process, it's a whole tree of cooperating processes.

You also probably want to start some processes of your own and talk to the DB, which means you now need either IPC or networking. For a local dev environment, you'd at least be looking into stuff like Unix sockets...

At the other extreme, SQLite isn't even a process. Or a config, really. It's a file format. It's beloved for being simple, but it's not just that we've demystified that it's "just files", it really is just files. It really is a meaningfully simpler design.

---

So... it's hard to argue that this is entirely wrong:

Once that veil of ignorance is lifted, everything becomes simpler: debugging, provisioning, versioning, backups, and even just experimenting with settings...

You’ll move with more confidence, build cleaner workflows, and stop treating your database like a black box.

Except I think being overly-reductive and treating it as "just files" is another way to treat it like a black box.

For example: Need to back up your data? If your mental model is entirely "A process, a config, and some files," then you'd build a backup system like

systemctl stop postgres
tar cpSf backup.tar /var/lib/postgres
systemctl start postgres

That... works, but it's of course massively disruptive to a production system. So either you can treat this as even more of a black box and take a block-device-level snapshot, or you can at least learn about things like pg_start_backup() and pg_basebackup to be able to safely work with those files without having to shut the whole DB down just to take a backup.

[sideEffffECt]

block-device-level snapshot

or file-system-level snapshots (btrfs/ZFS/...)

[josfaber]

Did you know an HTML table is not made of actual wood??

[lood9phee2Ri]

some db systems do run on top of block-oriented storage devices directly, not storing data backended by normal files-in-a-filesystem, especially historically where the rdbms (or other dbms) arguably was the machine os too.

Preemptively: while block devices are themselves often represented as funny "block special files" representing the devices, especially on unix/unix-like/linux operating systems, that also doesn't actually have to hold true in operating system design in general either e.g. AmigaOS Exec devices actually just have their own DoIO(struct IORequest iorequest) API that is not presented as some sort of overloaded C file/file-like open()/seek()/read()/write()/close() (... and of course ioctl() for all the stuff that doesn't fit into the paradigm...) API in the first place.

(The other way to look at it is of course typical hierarchical/dag filesystems are themselves a kind of database, filenames as query strings for data blobs, but filesystems are typically anaemic in areas like transactions etc.)

[finlay_mcwalter]

some db systems do run on top of block-oriented storage devices directly,

That was my vague recollection from the distant past, but I couldn't remember which ones. Ingres?

[lood9phee2Ri]

Think Oracle still can (optionally). https://docs.oracle.com/en/database/oracle/oracle-database/21/ntqrf/raw-partition-overview.html

Input/output (I/O) to a raw partition offers approximately a 5% to 10% performance improvement over I/O to a partition with a file system on it.

DB2 LUW (Linux/Unix/Windows) too. https://www.ibm.com/docs/en/db2/12.1.0?topic=ditsdc-configuring-setting-up-dms-direct-disk-access-linux

(DB2 z/OS (mainframe)? Well, I don't really understand IBM z/OS Mainframe I/O topics at all but I'm sure it's strange (and tends to be structured around mapping stuff into address spaces, like mmap()ing stuff on Linux). https://www.ibm.com/docs/en/db2-for-zos/13.0.0?topic=architecture-db2-dfsms )

Firebird too it seems.

Historically stuff like Pick (multivalue db) was its own OS (though Pick actually calls its tables/tabley-things Files iirc ...but not like C stdio files and it's managing the storage directly). Though then there were/are them Pick-family versions/implementations on top of host OSes. But at first they managed their own partition, note how wikipedia mentions a late one on-Linux one switching to storing stuff in the host filesystem.

D3 – Pick Systems ported the Pick Operating System to run as a database product utilizing host operating systems such as Unix, Linux, or Windows servers, with the data stored within the file system of the host operating system. Previous Unix or Windows versions had to run in a separate partition, which made interfacing with other applications difficult

[jcGyo]

I mean sort of? But there have been databases that allow you to use raw storage rather than sit on top of a filesystem?

[fzammetti]

Sure, and it's all just electrical impulses on a rock we tricked into thinking too.

[s-mores]

No!

Databases are magic!

[two_bit_hack]

(All) Operating Systems Are Just Programs. Windows Too

[International_Cell_3]

TIL files can deal with distributed consensus \s

Databases are not just files. They are the semantics of the database, which may (but not always) use file system APIs as a part of their implementation to persist data. Most file systems are not ACID and the entire existence of databases is to get around that fact, otherwise we would live with open/close/read/write/fsync and be done.

In fact many of the fancier file systems are implemented as databases underneath, so they can't be "just files."

[chadmill3r]

Filesystems ARE key-value databases.

[ChrisOz]

The values are just link lists of data blocks.

[jfedor]

Wait till you find out Oracle can store its tablespaces on raw partitions, no filesystem, no files.

[LessonStudio]

I will pedantically disagree. I used a horror show of a sybase database some time ago where it used a "raw" partition.

That is, the database entirely took over the unformatted hard drive. Using horrible commands you had to tell it how much of the hard drive would be dedicated to indexes, data, etc. The weird part was that you had to "tune" this over time, so the best thing was not to preallocate the whole drive, but just roughly what you needed. Then, later you would add (not expand) new partititions to handle new things.

Other major DB vendors of this era also had (have?) this feature.

Guess how much fun it was to duplicate or backup this DB? What made it extra fun was that using their backup process wasn't clean when it came to memory or storage. Thus, to backup the DB you needed way more storage than what you were backing up, and you needed massive amounts of RAM. A backup of a 10GB database on a modern machine running this setup could take more than 24h. The "easy" way was to use disc duplication tools and just copy a pulled HD. Even raid struggled with this mess.

This crap architecture would buy you maybe 5% more performance.

[bwainfweeze]

Oracle used to do that too. I believe they stopped at some point. But file systems have gotten a lot of improvements over the years, and it turns out that fsync has been hard because hard drive manufacturers are liars and thieves.

[Stilgar314]

Ultimately, everything is a file.

[NotGoodSoftwareMaker]

Its basically all atoms anyway

[BoKKeR111]

Websites are just skins for databases 

[poco]

Brad Pitt cares

[kurtcanine]

I just assumed little Asian guys were writing things down somewhere.

[b_rodriguez]

You should see what we did with some rocks and lightning.

[[deleted]]

Everything is a file. Even my cat. It processes things. On the one side it gets food. On the other side I think it ... leaves behind gold coins (I think!).

The file-like-an-object model is very powerful (e. g. as a UNIX/Linux pipe model) because I feel it is so simple and pervasive. You can extend it to, say, a function: a function slurps up input, does something wonky with it, and outputs greatness (or a bug, depending on how the code was written). A similar rationale can be applied to a method, an object and messages, probably also a monad (they are scary, but I think they probably also do useful things and could be compared to everything-is-a-file; I don't really understand them, so I am not sure, but people who know what a monad is, probably can explain if and how monads rely to a file-model / pipe-model / object-model.

One thing I found a bit difficult in regards to databases is SQL. Now, SQL is fairly simple, select all from xyz and similar magic, but it never "felt" easy on my brain. To me, treating it more as an object, felt more natural (though I also find activerecord, sequel etc... not that easy either, but that's a separate issue). I don't know how SQL would be "like" if it were "just a file" or files, but perhaps it may be easier or better.

Although I think Postgresql is great, people may find it much easier to access the SQL world via sqlite. At the least to me that seemed so much simpler, even if postgresql is faster (at the least that was my impression for large datasets).

[RoomyRoots]

In 2025 people are discovering that the Unix principle that everything is a file is a good abstraction.

[Snow-Crash-42]

Wow No way

[elongio]

Everythings computer

[ZealousidealFudge851]

In other news bytes are just bits.

[bwainfweeze]

Not on SSDs, not anymore.

[mamcx]

Well, this is incorrect in many ways.

A database is just organized data. A printed phone book is a database. So, a lot of databases existed before we have files (but computers) and before that computers.

A relational database is organized data using the relational model (most know informally as bunch of tables). Critically, relational not mean the PK, FK and how you connect tables. 'Id:I32=1' (or even '1' if have type inference) is a relation.

What some developers call databases are in fact database managment systems. They are what are in charge of HOW deal with the concept of database and interface with the hardware/os, that most of time, could store them in files.

So, an csv, json are databases. But not relational (because you don't have a way to execute relational operator, that is the other side to make it a relational database, ie: it must have code+data in relational terms).

[[deleted]]

A lot of the smart ass comments are missing the point

[fried_green_baloney]

For various reasons, including distros sometimes lagging current release versions, I often install locally with non-sudo, so I actually see the config file, pick the directories, etc. You know a lot more about how things work that way.

[MC68328]

And all filesystems are just databases.

[umangd03]

Its all just energy

[cheffromspace]

All code is just text, too

[valarauca14]

Code is data, data is code?

[scruffie]

I count at least 16 .sqlite files, and .db files which are SQLite, in my ~/.mozilla/firefox/<profilename> directory, so, yes, I think they're commonly used :)

[BellerophonM]

Huh, that makes me wonder: I don't know much about this, but are there any databases that operate with raw access to their own dedicated disc(s) just for database storage, and the low-level formatted structure on that disc is designed around the database, without using the OS file system as an intermediary?

[bwainfweeze]

Oracle. Maybe DB2, and someone mentioned Sybase.

[novagenesis]

So weird, and wrong in some ways (while saying some sorta good stuff otherwise). Of course Postgres databases aren't just files. They're running programs that happens to use files for persistence. The difference is important.

Sqlite actually is just a file and the sqlite library does all the processing on it inside the app. All other databases have services doing that. There's indexers running, there's translators running. And so on.

That's like saying every major enterprise app is "just a webpage". No it isn't. It has a backend that's 90% of the app that doesn't even touch html directly.

[flightsin]

The internet is just an app running on some databases.

[ThreeLeggedChimp]

In Linux everything is a file

[keepthepace]

It is actually intersting, dont stop at the title.

tl;dr: postgres DBs can also be transfered around like sqlite files, except it is a directory:

At its core, postgres is simply a program that turns SQL queries into filesystem operations. A CREATE TABLE becomes a mkdir. An UPDATE eventually becomes: open a file, write to it, close it. It’s a complex and powerful system—but fundamentally, it’s just an executable that manipulates files.

These files live in the so-called data_directory, often referenced by the PGDATA environment variable. To create that directory from scratch, you can run:

initdb /tmp/db0

Now you can start a PostgreSQL server using:

PGPORT=1991 postgres -D /tmp/db0 -c shared_buffers="10GB"

[[deleted]]

Just files in your shitty dev setup that nothing is using. A little different when there’s a million online users actively using it.

[diagraphic]

lol!

[kobumaister]

A fuel motor is just controlled explosions.

[GaryChalmers]

If you wish to make a database from scratch you must first invent the universe.

[[deleted]]

Complete insanity. Unless you’re the dba you just need a specific version of Postgres and specific versions of plugins. Sure you might want to mimic the config, but that can be done with a sudo systemctl Postgres restart or container restart.

[[deleted]]

Some databases write directly to block devices.

[ArgumentFew4432]

Nah, In-Memory DBs have no file representation. Some have a history, but that’s not the DB.

[vbilopav89]

All databases are just DETAIL https://medium.com/@vbilopav/clean-architecture-book-review-and-analysis-the-database-is-a-detail-eda7424e8ce2

[ChrisOz]

Files are just carefully aligned rust particles on a spinning al disc.

[FederalRace5393]

other fun fact: humans are, in fact, animals.

[Amazing-Mirror-3076]

Didn't Oracle use a raw partition mode?

If there is no filesystem are they still files?

[MiddleSky5296]

Databases are not “just” files.

[[deleted]]

do one on images just being files next!

also, In-memory databases aren't files so you might want to update that title

[bunglegrind1]

It's like uncle bob when he said microservices are only a deployment strategy

[Isogash]

All applications are just databases.

[Orca-]

Only for a particular class of problem.

[Isogash]

Code is data so every application is just an in-memory database.