Miniflux

The schema behind Miniflux, a minimalist feed reader, rebuilt from the migration strings in its Go source: users and how they sign in, the feeds and categories they follow, the entries fetched for them, and a few system tables.

16 tables · 272 columns · 14 foreign keys · 4 domains | 1 errors · 6 warnings · 9 notes

Generated from v2@2.3.3.sql on 2026-09-05.

Conventions

Every user-owned table carries user_id with ON DELETE CASCADE, so deleting a user takes their feeds and entries with it.
Timestamps are TIMESTAMP WITH TIME ZONE.

Conventions are claims. Findings below are where the schema breaks them.

Findings

Errors (1)

F001schema_versionprimary-key

No primary key

Without a primary key rows are not individually addressable: no safe UPDATE/DELETE of one row, no logical replication, ORMs misbehave, and duplicates are legal.

Fix Add a natural composite key or a surrogate id.

ALTER TABLE schema_version ADD PRIMARY KEY (...);

Warnings (6)

F003enclosures entry_idfk-index

Foreign key without index

PostgreSQL does not index FK columns automatically. Every DELETE/UPDATE on entries must scan enclosures to check the constraint, and every join from the parent side is a sequential scan. The scan cost grows with the child table forever, so this gets worse on its own. An index is not free. Every write to enclosures maintains it — insert, update and delete alike — and it takes disk. Weigh that against how often entries rows are actually deleted or re-keyed — if the answer is never, the scan never happens and the index only costs.

Fix Add an index on the FK column(s).

CREATE INDEX CONCURRENTLY idx_enclosures_entry_id ON enclosures(entry_id);

F007enclosures mime_typeundocumented-enum

Enum-like column with no CHECK

mime_type is a short string that clearly takes a fixed set of values, but the database accepts anything. Typos become new states, and nobody can list the legal values without reading application code.

Fix Add a CHECK constraint (cheap, easy to evolve) or a lookup table if values need metadata. Avoid native ENUM types unless the set is truly frozen.

ALTER TABLE enclosures ADD CONSTRAINT enclosures_mime_type_check CHECK (mime_type IN (...));

F004feed_icons icon_idfk-index

Foreign key without index

PostgreSQL does not index FK columns automatically. Every DELETE/UPDATE on icons must scan feed_icons to check the constraint, and every join from the parent side is a sequential scan. The scan cost grows with the child table forever, so this gets worse on its own. An index is not free. Every write to feed_icons maintains it — insert, update and delete alike — and it takes disk. Weigh that against how often icons rows are actually deleted or re-keyed — if the answer is never, the scan never happens and the index only costs.

Fix Add an index on the FK column(s).

CREATE INDEX CONCURRENTLY idx_feed_icons_icon_id ON feed_icons(icon_id);

F002feeds category_idfk-index

Foreign key without index

PostgreSQL does not index FK columns automatically. Every DELETE/UPDATE on categories must scan feeds to check the constraint, and every join from the parent side is a sequential scan. The scan cost grows with the child table forever, so this gets worse on its own. An index is not free. Every write to feeds maintains it — insert, update and delete alike — and it takes disk. Weigh that against how often categories rows are actually deleted or re-keyed — if the answer is never, the scan never happens and the index only costs.

Fix Add an index on the FK column(s).

CREATE INDEX CONCURRENTLY idx_feeds_category_id ON feeds(category_id);

F008icons mime_typeundocumented-enum

Enum-like column with no CHECK

Fix Add a CHECK constraint (cheap, easy to evolve) or a lookup table if values need metadata. Avoid native ENUM types unless the set is truly frozen.

ALTER TABLE icons ADD CONSTRAINT icons_mime_type_check CHECK (mime_type IN (...));

F005webauthn_credentials user_idfk-index

Foreign key without index

PostgreSQL does not index FK columns automatically. Every DELETE/UPDATE on users must scan webauthn_credentials to check the constraint, and every join from the parent side is a sequential scan. The scan cost grows with the child table forever, so this gets worse on its own. An index is not free. Every write to webauthn_credentials maintains it — insert, update and delete alike — and it takes disk. Weigh that against how often users rows are actually deleted or re-keyed — if the answer is never, the scan never happens and the index only costs.

Fix Add an index on the FK column(s).

CREATE INDEX CONCURRENTLY idx_webauthn_credentials_user_id ON webauthn_credentials(user_id);

Notes (9)

F012acme_cacheorphan-table

Isolated table

acme_cache references nothing and nothing references it. Either it is a staging/log table (fine, say so), or it is dead, or it is the seed of a second data model growing beside the first.

Fix Document its purpose or drop it.

F015feedswide-table

Wide table (42 columns)

Tables this wide usually hide several entities (or a JSON column that wants to be one). Every row update rewrites the whole tuple; TOAST kicks in; indexes bloat.

Fix Look for column groups that always change together and split them out.

F016integrationswide-table

Wide table (122 columns)

Tables this wide usually hide several entities (or a JSON column that wants to be one). Every row update rewrites the whole tuple; TOAST kicks in; indexes bloat.

Fix Look for column groups that always change together and split them out.

F009schema_versionorphan-table

Isolated table

schema_version references nothing and nothing references it. Either it is a staging/log table (fine, say so), or it is dead, or it is the seed of a second data model growing beside the first.

Fix Document its purpose or drop it.

F010sessionsorphan-table

Isolated table

sessions references nothing and nothing references it. Either it is a staging/log table (fine, say so), or it is dead, or it is the seed of a second data model growing beside the first.

Fix Document its purpose or drop it.

F011tokensorphan-table

Isolated table

tokens references nothing and nothing references it. Either it is a staging/log table (fine, say so), or it is dead, or it is the seed of a second data model growing beside the first.

Fix Document its purpose or drop it.

F013usersblast-radius

Hub table: referenced by 8 tables

Any change to its key, its delete semantics, or its partitioning touches every dependent. Migrations on hub tables need the longest lock windows and the most careful rollout.

Fix Treat schema changes here as breaking changes with a written rollout plan.

F014userswide-table

Wide table (32 columns)

Tables this wide usually hide several entities (or a JSON column that wants to be one). Every row update rewrites the whole tuple; TOAST kicks in; indexes bloat.

Fix Look for column groups that always change together and split them out.

F006web_sessions user_idfk-nullable

Nullable foreign key

web_sessions.user_id may be NULL, so the relationship to users is optional. That is legitimate (e.g. approved_by before approval) but often a modelling shrug: a row with no owner, or two nullable FKs that are secretly an either/or.

Fix Confirm the optionality is a domain rule; document it in the column comment.

Schema

16 tables · 14 foreign keys · 4 domains. Open the 3D explorer: rotate, zoom, click any table or relationship.

Users and access 6 tables

Users, their browser and API sessions, API keys, passkeys, and per-user third-party integrations.

Relationships

web_sessions.user_id → users.id — one users, many web_sessions · optional · ON DELETE CASCADE · indexed
why: not documented
api_keys.user_id → users.id — one users, many api_keys · required · ON DELETE CASCADE · indexed
why: not documented
webauthn_credentials.user_id → users.id — one users, many webauthn_credentials · required · ON DELETE CASCADE · not indexed
why: not documented
integrations.user_id → users.id — one users, at most one integrations · required · ON DELETE CASCADE · indexed
why: not documented

users

32 cols · no RLS · line 5View in 3D

Hub table: referenced by 8 tables — Any change to its key, its delete semantics, or its partitioning touches every dependent. Migrations on hub tables need the longest lock windows and the most careful rollout.
Wide table (32 columns) — Tables this wide usually hide several entities (or a JSON column that wants to be one). Every row update rewrites the whole tuple; TOAST kicks in; indexes bloat.

Column	Type	Null	Default
`id` PK	serial	NOT NULL
`username` UK	text	NOT NULL
`password`	text	null
`is_admin`	bool	null	'f'
`language`	text	null	'en_US'
`timezone`	text	null	'UTC'
`theme`	text	null	'default'
`last_login_at`	timestamptz	null
`entry_direction`	entry_sorting_direction	null
`keyboard_shortcuts`	boolean	null
`entries_per_page`	integer	null
`show_reading_time`	boolean	null
`entry_swipe`	boolean	null
`stylesheet`	text	null
`google_id`	text	null
`openid_connect_id`	text	null
`display_mode`	webapp_display_mode	null
`entry_order`	entry_sorting_order	null
`default_reading_speed`	integer	null
`cjk_reading_speed`	integer	null
`default_home_page`	text	null
`categories_sorting_order`	text	null
`double_tap`	boolean	null
`mark_read_on_view`	boolean	null
`media_playback_rate`	numeric	null
`block_filter_entry_rules`	text	null
`keep_filter_entry_rules`	text	null
`mark_read_on_media_player_completion`	bool	null
`custom_js`	text	null
`external_font_hosts`	text	null
`always_open_external_links`	bool	null
`open_external_links_in_new_tab`	bool	null

Indexes

UNIQUE (google_id) WHERE google_id <> '' users_google_id_idx
UNIQUE (openid_connect_id) WHERE openid_connect_id <> '' users_openid_connect_id_idx

Referenced by

categories (user_id, 1:N)
feeds (user_id, 1:N)
entries (user_id, 1:N)
enclosures (user_id, 1:N)
integrations (user_id, 1:1)
api_keys (user_id, 1:N)
webauthn_credentials (user_id, 1:N)
web_sessions (user_id, 1:N)

sessions

3 cols · no RLS · line 141View in 3D

Isolated table — sessions references nothing and nothing references it. Either it is a staging/log table (fine, say so), or it is dead, or it is the seed of a second data model growing beside the first.

Column	Type	Null	Default
`id` PK	text	NOT NULL
`data`	jsonb	NOT NULL
`created_at`	timestamptz	NOT NULL	now()

Indexes

none

Referenced by

nothing

web_sessions

7 cols · no RLS · line 595View in 3D

Nullable foreign key user_id — web_sessions.user_id may be NULL, so the relationship to users is optional. That is legitimate (e.g. approved_by before approval) but often a modelling shrug: a row with no owner, or two nullable FKs that are secretly an either/or.

Column	Type	Null	Default	References	Notes
`id` PK	text	NOT NULL
`secret_hash`	bytea	NOT NULL
`user_id`	integer	null		users.id 1:N · CASCADE
`created_at`	timestamptz	NOT NULL	now()
`user_agent`	text	NOT NULL	''
`ip`	inet	null
`state`	jsonb	NOT NULL	CAST('{}' AS jsonb)		`CHECK jsonb_typeof(state) = 'object'`

Indexes

(user_id) WHERE user_id IS NOT NULL web_sessions_user_id_idx
(created_at) web_sessions_created_at_idx

Referenced by

nothing

Table checks: jsonb_typeof(state) = 'object'

api_keys

6 cols · no RLS · line 205View in 3D

Column	Type	Null	Default	References
`id` PK	serial	NOT NULL
`user_id`	integer	NOT NULL		users.id 1:N · CASCADE
`token` UK	text	NOT NULL
`description`	text	NOT NULL
`last_used_at`	timestamptz	null
`created_at`	timestamptz	null	now()

Indexes

none

Referenced by

nothing

webauthn_credentials

13 cols · no RLS · line 405View in 3D

Foreign key without index user_id — PostgreSQL does not index FK columns automatically. Every DELETE/UPDATE on users must scan webauthn_credentials to check the constraint, and every join from the parent side is a sequential scan. The scan cost grows with the child table forever, so this gets worse on its own. An index is not free. Every write to webauthn_credentials maintains it — insert, update and delete alike — and it takes disk. Weigh that against how often users rows are actually deleted or re-keyed — if the answer is never, the scan never happens and the index only costs.

Column	Type	Null	Default	References
`handle` PK	bytea	NOT NULL
`cred_id` UK	bytea	NOT NULL
`user_id`	integer	NOT NULL		users.id 1:N · CASCADE
`public_key`	bytea	NOT NULL
`attestation_type`	varchar(255)	NOT NULL
`aaguid`	bytea	null
`sign_count`	bigint	null
`clone_warning`	bool	null
`name`	text	null
`added_on`	timestamptz	null	now()
`last_seen_on`	timestamptz	null	now()
`backup_eligible`	boolean	null
`backup_state`	boolean	null

Indexes

none

Referenced by

nothing

integrations

122 cols · no RLS · line 115View in 3D

Wide table (122 columns) — Tables this wide usually hide several entities (or a JSON column that wants to be one). Every row update rewrites the whole tuple; TOAST kicks in; indexes bloat.

Column	Type	Null	Default	References
`user_id` PK	integer	NOT NULL		users.id 1:1 · CASCADE
`pinboard_enabled`	bool	null	'f'
`pinboard_token`	text	null	''
`pinboard_tags`	text	null	'miniflux'
`pinboard_mark_as_unread`	bool	null	'f'
`instapaper_enabled`	bool	null	'f'
`instapaper_username`	text	null	''
`instapaper_password`	text	null	''
`fever_enabled`	bool	null	'f'
`fever_username`	text	null	''
`fever_token`	text	null	''
`wallabag_enabled`	bool	null
`wallabag_url`	text	null
`wallabag_client_id`	text	null
`wallabag_client_secret`	text	null
`wallabag_username`	text	null
`wallabag_password`	text	null
`nunux_keeper_enabled`	bool	null
`nunux_keeper_url`	text	null
`nunux_keeper_api_key`	text	null
`telegram_bot_enabled`	bool	null
`telegram_bot_token`	text	null
`telegram_bot_chat_id`	text	null
`googlereader_enabled`	bool	null
`googlereader_username`	text	null
`googlereader_password`	text	null
`espial_enabled`	bool	null
`espial_url`	text	null
`espial_api_key`	text	null
`espial_tags`	text	null
`linkding_enabled`	bool	null
`linkding_url`	text	null
`linkding_api_key`	text	null
`wallabag_only_url`	bool	null
`matrix_bot_enabled`	bool	null
`matrix_bot_user`	text	null
`matrix_bot_password`	text	null
`matrix_bot_url`	text	null
`matrix_bot_chat_id`	text	null
`linkding_tags`	text	null
`linkding_mark_as_unread`	bool	null
`notion_enabled`	bool	null
`notion_token`	text	null
`notion_page_id`	text	null
`readwise_enabled`	bool	null
`readwise_api_key`	text	null
`apprise_enabled`	bool	null
`apprise_url`	text	null
`apprise_services_url`	text	null
`shiori_enabled`	bool	null
`shiori_url`	text	null
`shiori_username`	text	null
`shiori_password`	text	null
`shaarli_enabled`	bool	null
`shaarli_url`	text	null
`shaarli_api_secret`	text	null
`webhook_enabled`	bool	null
`webhook_url`	text	null
`webhook_secret`	text	null
`telegram_bot_topic_id`	integer	null
`telegram_bot_disable_web_page_preview`	bool	null
`telegram_bot_disable_notification`	bool	null
`telegram_bot_disable_buttons`	bool	null
`rssbridge_enabled`	bool	null
`rssbridge_url`	text	null
`omnivore_enabled`	bool	null
`omnivore_api_key`	text	null
`omnivore_url`	text	null
`linkace_enabled`	bool	null
`linkace_url`	text	null
`linkace_api_key`	text	null
`linkace_tags`	text	null
`linkace_is_private`	bool	null
`linkace_check_disabled`	bool	null
`linkwarden_enabled`	bool	null
`linkwarden_url`	text	null
`linkwarden_api_key`	text	null
`readeck_enabled`	bool	null
`readeck_only_url`	bool	null
`readeck_url`	text	null
`readeck_api_key`	text	null
`readeck_labels`	text	null
`raindrop_enabled`	bool	null
`raindrop_token`	text	null
`raindrop_collection_id`	text	null
`raindrop_tags`	text	null
`betula_url`	text	null
`betula_token`	text	null
`betula_enabled`	bool	null
`ntfy_enabled`	bool	null
`ntfy_url`	text	null
`ntfy_topic`	text	null
`ntfy_api_token`	text	null
`ntfy_username`	text	null
`ntfy_password`	text	null
`ntfy_icon_url`	text	null
`cubox_enabled`	bool	null
`cubox_api_link`	text	null
`discord_enabled`	bool	null
`discord_webhook_link`	text	null
`ntfy_internal_links`	bool	null
`slack_enabled`	bool	null
`slack_webhook_link`	text	null
`pushover_enabled`	bool	null
`pushover_user`	text	null
`pushover_token`	text	null
`pushover_device`	text	null
`pushover_prefix`	text	null
`rssbridge_token`	text	null
`karakeep_enabled`	bool	null
`karakeep_api_key`	text	null
`karakeep_url`	text	null
`linktaco_enabled`	bool	null
`linktaco_api_token`	text	null
`linktaco_org_slug`	text	null
`linktaco_tags`	text	null
`linktaco_visibility`	linktaco_link_visibility	null
`wallabag_tags`	text	null
`archiveorg_enabled`	bool	null
`karakeep_tags`	text	null
`linkwarden_collection_id`	integer	null
`readeck_push_enabled`	bool	null

Indexes

none

Referenced by

nothing

Feeds 4 tables

Feeds and the categories that group them, plus the deduplicated icons feeds share.

Relationships

categories.user_id → users.id — one users, many categories · required · ON DELETE CASCADE · indexed
why: not documented
feeds.user_id → users.id — one users, many feeds · required · ON DELETE CASCADE · indexed
why: not documented
feeds.category_id → categories.id — one categories, many feeds · required · ON DELETE CASCADE · not indexed
why: not documented
feed_icons.feed_id → feeds.id — one feeds, many feed_icons · required · ON DELETE CASCADE · indexed
why: not documented
feed_icons.icon_id → icons.id — one icons, many feed_icons · required · ON DELETE CASCADE · not indexed
why: not documented

feeds

42 cols · no RLS · line 38View in 3D

Foreign key without index category_id — PostgreSQL does not index FK columns automatically. Every DELETE/UPDATE on categories must scan feeds to check the constraint, and every join from the parent side is a sequential scan. The scan cost grows with the child table forever, so this gets worse on its own. An index is not free. Every write to feeds maintains it — insert, update and delete alike — and it takes disk. Weigh that against how often categories rows are actually deleted or re-keyed — if the answer is never, the scan never happens and the index only costs.
Wide table (42 columns) — Tables this wide usually hide several entities (or a JSON column that wants to be one). Every row update rewrites the whole tuple; TOAST kicks in; indexes bloat.

Column	Type	Null	Default	References
`id` PK	bigserial	NOT NULL
`user_id`	integer	NOT NULL		users.id 1:N · CASCADE
`category_id`	integer	NOT NULL		categories.id 1:N · CASCADE
`title`	text	NOT NULL
`feed_url`	text	NOT NULL
`site_url`	text	NOT NULL
`checked_at`	timestamptz	null	now()
`etag_header`	text	null	''
`last_modified_header`	text	null	''
`parsing_error_msg`	text	null	''
`parsing_error_count`	integer	null	0
`scraper_rules`	text	null
`rewrite_rules`	text	null
`crawler`	boolean	null
`username`	text	null
`password`	text	null
`user_agent`	text	null
`disabled`	boolean	null
`next_check_at`	timestamptz	null
`ignore_http_cache`	bool	null
`fetch_via_proxy`	bool	null
`blocklist_rules`	text	null
`keeplist_rules`	text	null
`allow_self_signed_certificates`	boolean	null
`cookie`	text	null
`hide_globally`	boolean	null
`url_rewrite_rules`	text	null
`no_media_player`	boolean	null
`apprise_service_urls`	text	null
`disable_http2`	bool	null
`description`	text	null
`ntfy_enabled`	bool	null
`ntfy_priority`	integer	null
`webhook_url`	text	null
`pushover_enabled`	bool	null
`pushover_priority`	integer	null
`ntfy_topic`	text	null
`proxy_url`	text	null
`block_filter_entry_rules`	text	null
`keep_filter_entry_rules`	text	null
`ignore_entry_updates`	bool	null
`language`	text	null

Indexes

(user_id, category_id) feeds_user_category_idx

Referenced by

entries (feed_id, 1:N)
feed_icons (feed_id, 1:N)
entry_tombstones (feed_id, 1:N)

icons

5 cols · no RLS · line 89View in 3D

Enum-like column with no CHECK mime_type — mime_type is a short string that clearly takes a fixed set of values, but the database accepts anything. Typos become new states, and nobody can list the legal values without reading application code.

Column	Type	Null
`id` PK	bigserial	NOT NULL
`hash` UK	text	NOT NULL
`mime_type`	text	NOT NULL
`content`	bytea	NOT NULL
`external_id`	text	null

Indexes

UNIQUE (external_id) WHERE external_id <> '' icons_external_id_idx

Referenced by

feed_icons (icon_id, 1:N)

feed_icons

2 cols · no RLS · line 97View in 3D

Foreign key without index icon_id — PostgreSQL does not index FK columns automatically. Every DELETE/UPDATE on icons must scan feed_icons to check the constraint, and every join from the parent side is a sequential scan. The scan cost grows with the child table forever, so this gets worse on its own. An index is not free. Every write to feed_icons maintains it — insert, update and delete alike — and it takes disk. Weigh that against how often icons rows are actually deleted or re-keyed — if the answer is never, the scan never happens and the index only costs.

Column	Type	Null	Default	References	Notes
`feed_id` PK	bigint	NOT NULL		feeds.id 1:N · CASCADE
`icon_id` PK	bigint	NOT NULL		icons.id 1:N · CASCADE

Indexes

none

Referenced by

nothing

Entries 3 tables

Fetched entries, their enclosures, and the tombstones that keep a deleted entry from coming back.

Relationships

entries.user_id → users.id — one users, many entries · required · ON DELETE CASCADE · indexed
why: not documented
entries.feed_id → feeds.id — one feeds, many entries · required · ON DELETE CASCADE · indexed
why: not documented
enclosures.user_id → users.id — one users, many enclosures · required · ON DELETE CASCADE · indexed
why: not documented
enclosures.entry_id → entries.id — one entries, many enclosures · required · ON DELETE CASCADE · not indexed
why: not documented
entry_tombstones.feed_id → feeds.id — one feeds, many entry_tombstones · required · ON DELETE CASCADE · indexed
why: not documented

entries

19 cols · no RLS · line 58View in 3D

Column	Type	Null	Default	References
`id` PK	bigserial	NOT NULL
`user_id`	integer	NOT NULL		users.id 1:N · CASCADE
`feed_id`	bigint	NOT NULL		feeds.id 1:N · CASCADE
`hash`	text	NOT NULL
`published_at`	timestamptz	NOT NULL
`title`	text	NOT NULL
`url`	text	NOT NULL
`author`	text	null
`content`	text	null
`status`	entry_status	null	'unread'
`starred`	bool	null
`comments_url`	text	null
`document_vectors`	tsvector	null
`changed_at`	timestamptz	null
`share_code`	text	null
`reading_time`	integer	null
`created_at`	timestamptz	null
`tags`	text[]	null
`language`	text	null

Indexes

(feed_id) entries_feed_idx
(user_id, status) entries_user_status_idx
(document_vectors) document_vectors_idx
UNIQUE (share_code) WHERE share_code <> '' entries_share_code_idx
(user_id, feed_id) entries_user_feed_idx
(id, user_id, status) entries_id_user_status_idx
(feed_id, status, hash) entries_feed_id_status_hash_idx
(user_id, status, starred) entries_user_id_status_starred_idx
(feed_id, url) WHERE length(url) < 2000 entries_feed_url_idx
(user_id, status, feed_id) entries_user_status_feed_idx
(user_id, status, changed_at) entries_user_status_changed_idx
(document_vectors) WHERE status <> 'removed' document_vectors_idx
(document_vectors) document_vectors_idx

Referenced by

enclosures (entry_id, 1:N)

enclosures

7 cols · no RLS · line 77View in 3D

Foreign key without index entry_id — PostgreSQL does not index FK columns automatically. Every DELETE/UPDATE on entries must scan enclosures to check the constraint, and every join from the parent side is a sequential scan. The scan cost grows with the child table forever, so this gets worse on its own. An index is not free. Every write to enclosures maintains it — insert, update and delete alike — and it takes disk. Weigh that against how often entries rows are actually deleted or re-keyed — if the answer is never, the scan never happens and the index only costs.
Enum-like column with no CHECK mime_type — mime_type is a short string that clearly takes a fixed set of values, but the database accepts anything. Typos become new states, and nobody can list the legal values without reading application code.

Column	Type	Null	Default	References
`id` PK	bigserial	NOT NULL
`user_id`	integer	NOT NULL		users.id 1:N · CASCADE
`entry_id`	bigint	NOT NULL		entries.id 1:N · CASCADE
`url`	text	NOT NULL
`size`	integer	null	0
`mime_type`	text	null	''
`media_progression`	integer	null

Indexes

(user_id, entry_id, encode(sha256(CAST(url AS bytea)), 'hex')) enclosures_user_entry_url_idx
UNIQUE (user_id, entry_id, encode(sha256(CAST(url AS bytea)), 'hex')) enclosures_user_entry_url_unique_idx
UNIQUE (user_id, entry_id, encode(sha256(CAST(url AS bytea)), 'hex')) enclosures_user_entry_url_unique_idx

Referenced by

nothing

entry_tombstones

3 cols · no RLS · line 614View in 3D

Column	Type	Null	Default	References	Notes
`feed_id` PK	bigint	NOT NULL		feeds.id 1:N · CASCADE
`hash` PK	text	NOT NULL			`CHECK hash <> ''`
`deleted_at`	timestamptz	NOT NULL	now()

Indexes

(deleted_at) entry_tombstones_deleted_at_idx

Referenced by

nothing

System 3 tables

Schema version, CSRF tokens, and the ACME certificate cache.

Relationships

No foreign keys in this domain.

schema_version

1 cols · no RLS · line 1View in 3D

No primary key — Without a primary key rows are not individually addressable: no safe UPDATE/DELETE of one row, no logical replication, ORMs misbehave, and duplicates are legal.
Isolated table — schema_version references nothing and nothing references it. Either it is a staging/log table (fine, say so), or it is dead, or it is the seed of a second data model growing beside the first.

Column	Type	Null	Default	References	Notes
`version`	text	NOT NULL

Indexes

none

Referenced by

nothing

tokens

3 cols · no RLS · line 105View in 3D

Isolated table — tokens references nothing and nothing references it. Either it is a staging/log table (fine, say so), or it is dead, or it is the seed of a second data model growing beside the first.

Column	Type	Null	Default
`id` PK	text	NOT NULL
`value` PK	text	NOT NULL
`created_at`	timestamptz	NOT NULL	now()

Indexes

none

Referenced by

nothing

acme_cache

3 cols · no RLS · line 274View in 3D

Isolated table — acme_cache references nothing and nothing references it. Either it is a staging/log table (fine, say so), or it is dead, or it is the seed of a second data model growing beside the first.

Column	Type	Null
`key` PK	varchar(400)	NOT NULL
`data`	bytea	NOT NULL
`updated_at`	timestamptz	NOT NULL

Indexes

none

Referenced by

nothing