Even with no ORM involved, 1-1 relations help keep things conceptually separate. This makes e.g spinning off parts of your application as microservices much easier, if the need ever arises.

How do you enforce the 1:1 relationship at the database level?

With an unique constraint/index

Yes, I mentioned the approach elsewhere. Now you have two database things (the FK and the constraint) describing a single relationship.

I don't think it's very elegant and people often forget the unique constraint.

One table is a much better solution.

Both tables have an ID primary key, one is also a FOREIGN KEY to the other.

1:1 mapping means that if one table has a row, so does the other.

How does this guarantee that the ID is in both tables?

> How does this guarantee that the ID is in both tables?

Create both tables, with the same PK the second with a deferrable, initially deferred foreign key to the first.

Alter the first to add a deferrable, initially deferred foreign key to the second. [Edited to correct swapped table refs in this ¶]

Mission accomplished.

Something like this (adjust the primary key name convention and schema as needed):

  create procedure mandatory_ (_table_name "text", _mandatory_table_name "text") language plpgsql as $$
        declare
                _trigger_name "text";
        begin
                _trigger_name = _table_name || '_mandatory_' || _mandatory_table_name || '_trigger';
                execute
                        'create function "' || _trigger_name || '_" () returns trigger language plpgsql as $' || '$ '
                                'begin '
                                        'if not exists '
                                                '( select 1 '
                                                        'from public."' || _mandatory_table_name || '" _mandatory '
                                                        'where _mandatory ."' || _table_name || '_id" = new ."id" ) '
                                        'then '
                                                'raise '
                                                        '''non-existent relation between "%" and "%" violates mandatory participation constraint'' '
                                                        ', ' || quote_literal (_table_name) ||
                                                        ', ' || quote_literal (_mandatory_table_name) || '; '
                                                'end if;'
                                        'return new; '
                                        'end; '
                                '$' || '$ ';
                execute
                        'create constraint trigger "' || _trigger_name || '" '
                                'after insert or update on "' || _table_name || '" '
                                'deferrable initially deferred '
                                'for each row execute function "' || _table_name || '_mandatory_' || _mandatory_table_name || '_trigger_" () ';
                end;
        $$;

Doesn't this require support for deferrable constraints? Even if they are supported on the transaction level, once you have these kinds of dependency loops, they tend to impact lots and lots of things—restoring from backups, application-level replication, and so on.

That's a 1:N relationship. There's nothing to prevent you from adding more related records.

At the database level there's only one kind of foreign key.

Yeah, you can try and prevent it from happening in code or throw some unique constraints at it, but it's unnecessary.

If the foreign key column is also that table’s primary key (or just has a unique constraint), then that’s not 1:N, it’s 1:1 or 1:0.

If you could it would become impossible to insert any data in them.

This Django example is more of a "[one or zero] to [one or zero]" relationship, that's likely what the grandparent post means. I doubt any of the mainstream relational databases have a way to enforce exact one-to-one correspondence between two tables. You could use triggers that execute at the end of transactions or something like that - but that's not part of the relational model.

This is related to what I meant, but specifically I was referring to the inability of databases to prevent a 1:1 becoming a 1:2 (or 1:N).

Yes, you can hack it with a unique constraint, but it's not very elegant.

That’s pretty much exactly what unique constraints are for. Why do you consider that a hack?

I still fail to see how your single table approach is more normalized. Consider for example an e-commerce order that may have either (1) exactly one shipping address or (2) no shipping address (for things like digital, downloadable products). You’re saying that you’d rather store the address data on the order table using a bunch of nullable fields? That bloats the order table and introduces a ton of possible consistency problems. A much more normalized model, IMO, would be to separate the address fields into their own table and use the unique FK approach to ensure that no order has more than one related address. Precisely which rules of normalization is that breaking? And how would they be resolved by putting everything into a single table?

I mean at the database level. Your relationships are foreign keys and they're 1:N.

Yes, you can try and artificially limit them to 1:1 using constraints but it's a hack.

The correct way to represent a 1:1 relationship in a database is with one table.