diff --git a/cypress/component/ContentReferenceWidget-relation.cy.js b/cypress/component/ContentReferenceWidget-relation.cy.js
index 1d498fdfbf..6b422c8465 100644
--- a/cypress/component/ContentReferenceWidget-relation.cy.js
+++ b/cypress/component/ContentReferenceWidget-relation.cy.js
@@ -100,7 +100,10 @@ describe('ContentReferenceWidget - relation', () => {
 		// Mock relation data so the relation cell can resolve its label
 		cy.reply('**/apps/tables/api/1/tables/42/relations', {
 			2: {
-				100: { id: '100', label: 'Alice' },
+				column: null,
+				values: {
+					100: { id: 100, value: 'Alice' },
+				},
 			},
 		})
 
diff --git a/cypress/component/Lookup.cy.js b/cypress/component/Lookup.cy.js
new file mode 100644
index 0000000000..e5ecbcd28a
--- /dev/null
+++ b/cypress/component/Lookup.cy.js
@@ -0,0 +1,229 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { createPinia, setActivePinia } from 'pinia'
+import { translate as t, translatePlural as n } from '@nextcloud/l10n'
+import { useDataStore } from '../../src/store/data.js'
+import { useTablesStore } from '../../src/store/store.js'
+import { parseCol } from '../../src/shared/components/ncTable/mixins/columnParser.js'
+import LookupColumn from '../../src/shared/components/ncTable/mixins/columnsTypes/lookup.js'
+import TableCellLookup from '../../src/shared/components/ncTable/partials/TableCellLookup.vue'
+import LookupForm from '../../src/shared/components/ncTable/partials/columnTypePartials/forms/LookupForm.vue'
+import NcTable from '../../src/shared/components/ncTable/NcTable.vue'
+import rowHelper from '../../src/shared/components/ncTable/mixins/rowHelper.js'
+import ColumnFormComponent from '../../src/modules/main/partials/ColumnFormComponent.vue'
+import TableRow from '../../src/shared/components/ncTable/partials/TableRow.vue'
+import TableCellTextLine from '../../src/shared/components/ncTable/partials/TableCellTextLine.vue'
+
+const targetColumn = (overrides = {}) => ({
+	id: 20,
+	tableId: 2,
+	title: 'City',
+	type: 'text',
+	subtype: 'line',
+	mandatory: false,
+	customSettings: {},
+	...overrides,
+})
+
+const sourceRelation = {
+	id: 7,
+	tableId: 1,
+	title: 'Person',
+	type: 'relation',
+	subtype: '',
+	customSettings: { relationType: 'view', targetId: 2, labelColumn: 20 },
+}
+
+const sourceRow = (id, value) => ({ id, data: [{ columnId: 7, value }] })
+
+let pinia
+let store
+let column
+
+function mount(component, props) {
+	return cy.mount(component, {
+		props,
+		global: {
+			plugins: [pinia],
+			mixins: [{ methods: { t, n } }],
+			config: { globalProperties: { OC: window.OC, OCA: window.OCA } },
+		},
+	})
+}
+
+function setLookup(target, values, loading = false) {
+	store.relations[8] = {
+		column: parseCol(target),
+		values: Object.fromEntries(Object.entries(values).map(([id, value]) => [id, { id: Number(id), value }])),
+		loading,
+	}
+}
+
+describe('Lookup behavior', () => {
+	beforeEach(() => {
+		pinia = createPinia()
+		setActivePinia(pinia)
+		store = useDataStore()
+		column = new LookupColumn({
+			id: 8,
+			tableId: 1,
+			title: 'City of person',
+			customSettings: { relationColumnId: 7, targetColumnId: 20 },
+		})
+		store.columns['1'] = [column]
+	})
+
+	it('dispatches the lookup form for the lookup API type', () => {
+		setLookup(targetColumn(), { 42: 'Berlin' })
+		mount(ColumnFormComponent, { column, value: 42 })
+		cy.contains('Berlin').should('be.visible')
+		cy.then(() => expect(column.type).to.equal('lookup'))
+	})
+
+	it('renders a looked-up text value without an editor', () => {
+		setLookup(targetColumn(), { 42: 'Berlin' })
+		mount(TableCellLookup, { column, value: 42, rowId: 1 })
+		cy.contains('Berlin').click()
+		cy.get('input, textarea').should('not.exist')
+		cy.then(() => expect(column.getValueString({ value: 42 })).to.equal('Berlin'))
+	})
+
+	for (const isView of [false, true]) {
+		it(`blocks inline lookup editing in a fallback renderer (isView=${isView})`, () => {
+			mount(TableCellTextLine, { column, value: 'Berlin', rowId: 1, canEdit: true, isView })
+			cy.contains('Berlin').click()
+			cy.get('input, textarea, .inline-editing-container').should('not.exist')
+		})
+	}
+
+	it('keeps lookup clicks read-only while allowing inline editing of ordinary columns', () => {
+		setLookup(targetColumn(), { 42: 'Berlin' })
+		const ownColumn = parseCol(targetColumn({ id: 9, tableId: 1, title: 'Own value' }))
+		const row = sourceRow(1, 42)
+		row.data.push({ columnId: 9, value: 'Editable value' })
+		const onEditRow = cy.stub().as('editRow')
+		mount(TableRow, {
+			row,
+			columns: [column, ownColumn],
+			config: { canEditRows: true, canSelectRows: false, showActions: false },
+			isView: false,
+			elementId: 1,
+			onEditRow,
+		})
+		cy.contains('td', 'Berlin').click()
+		cy.get('input, textarea, .inline-editing-container').should('not.exist')
+		cy.get('@editRow').should('not.have.been.called')
+		cy.contains('td', 'Editable value').click()
+		cy.get('input').should('be.visible').and('have.value', 'Editable value')
+	})
+
+	it('keeps numeric lookup values typed and formats zero correctly', () => {
+		setLookup(targetColumn({ type: 'number', subtype: '', numberDecimals: 2, numberPrefix: '$', numberSuffix: ' USD' }), { 42: 0 })
+		mount(TableCellLookup, { column, value: 42, rowId: 1 })
+		cy.get('.cell-number').should('contain', '0.00').and('contain', '$').and('contain', 'USD').and('not.contain', 'NaN')
+		cy.then(() => { store.relations[8].values[42].value = 12.5 })
+		cy.get('.cell-number').should('contain', '12.50')
+		cy.then(() => expect(column.getValueString({ value: 42 })).to.equal(12.5))
+	})
+
+	it('distinguishes loading, unavailable, and empty values without exporting row IDs', () => {
+		setLookup(targetColumn(), { 42: 'Old value' }, true)
+		mount(TableCellLookup, { column, value: 42, rowId: 1 })
+		cy.get('[aria-label="Loading lookup value"]').should('exist')
+		cy.contains('Old value').should('not.exist')
+		cy.then(() => { store.relations[8] = { column: null, values: {}, loading: false } })
+		cy.contains('Unavailable').should('be.visible')
+		cy.then(() => {
+			expect(column.getValueString({ value: 42 })).to.equal('')
+			expect(column.resolveValue(null).status).to.equal('unavailable')
+			expect(column.isSearchStringFound({ value: 42 }, '42')).to.equal(false)
+		})
+	})
+
+	it('renders an empty target value without treating the reference as unavailable', () => {
+		setLookup(targetColumn(), { 42: null })
+		mount(TableCellLookup, { column, value: 42, rowId: 1 })
+		cy.contains('Unavailable').should('not.exist')
+		cy.then(() => {
+			expect(column.getValueString({ value: 42 })).to.equal('')
+			expect(column.resolveValue(null).status).to.equal('empty')
+		})
+	})
+
+	it('searches and sorts lookup-only table columns through hidden relation cells', () => {
+		setLookup(targetColumn(), { 42: 'Zurich', 43: 'Amsterdam', 44: 'Berlin' })
+		mount(NcTable, {
+			columns: [column],
+			rows: [sourceRow(1, 42), sourceRow(2, 43), sourceRow(3, 44)],
+			viewSetting: { searchString: 'berlin', sorting: [{ columnId: 8, mode: 'ASC' }] },
+			showActions: false,
+			canSelectRows: false,
+		})
+		cy.get('[data-cy="customTableRow"]').should('have.length', 1).and('contain', 'Berlin')
+		cy.then(() => {
+			const rows = [sourceRow(1, 42), sourceRow(2, 43)]
+			expect(rows.sort(column.sort('ASC')).map(row => row.id)).to.deep.equal([2, 1])
+			expect(rows.sort(column.sort('DESC')).map(row => row.id)).to.deep.equal([1, 2])
+		})
+	})
+
+	it('sorts numeric lookups numerically, retaining zero and secondary sorting', () => {
+		setLookup(targetColumn({ type: 'number', subtype: '' }), { 42: 10, 43: 2, 44: 0, 45: -1, 46: 2 })
+		cy.then(() => {
+			const rows = [sourceRow(1, 42), sourceRow(2, 43), sourceRow(3, 44), sourceRow(4, 45), sourceRow(5, 46)]
+			const secondary = (a, b) => b.id - a.id
+			expect(rows.sort(column.sort('ASC', [secondary])).map(row => row.id)).to.deep.equal([4, 3, 5, 2, 1])
+		})
+	})
+
+	it('ignores legacy mandatory flags on virtual lookup columns', () => {
+		column.mandatory = true
+		column.viewColumnInformation = { mandatory: true }
+		cy.then(() => {
+			const helper = { ...rowHelper.methods, columns: [column] }
+			expect(helper.isMandatory(column)).to.equal(false)
+			expect(helper.checkMandatoryFields({ 7: 42 })).to.equal(false)
+		})
+	})
+
+	it('configures lookups from a source view without requiring the target view in navigation', () => {
+		const tables = useTablesStore()
+		tables.views = [{ id: 3, tableId: 1 }]
+		tables.setActiveViewId(3)
+		store.columns = {}
+		cy.intercept('GET', '**/apps/tables/api/1/tables/1/columns?viewId=3', [sourceRelation]).as('sourceColumns')
+		cy.intercept('GET', '**/apps/tables/api/1/views/2/columns', [
+			targetColumn(),
+			targetColumn({ id: 21, type: 'relation', subtype: '', title: 'Nested relation' }),
+			targetColumn({ id: 22, type: 'lookup', subtype: '', title: 'Nested lookup' }),
+		]).as('targetColumns')
+		mount(LookupForm, { column })
+		cy.wait(['@sourceColumns', '@targetColumns'])
+		cy.get('[aria-label="Select target column"]').click()
+		cy.get('.vs__dropdown-menu').should('contain', 'City').and('not.contain', 'Nested relation').and('not.contain', 'Nested lookup')
+	})
+
+	it('loads relation data through the public endpoint and clears omitted entries on refresh', () => {
+		const token = 'abcdefghijklmnop'
+		store.setPublicToken(token)
+		store.columns['public-' + token] = [column]
+		let response = { 8: { column: targetColumn(), values: { 42: { id: 42, value: 'Berlin' } } } }
+		cy.intercept('GET', '**/apps/tables/api/2/public/' + token + '/relations*', req => {
+			req.reply({ ocs: { data: response } })
+		}).as('publicRelations')
+		cy.then(() => store.loadRelationsFromBE({ token }))
+		cy.then(() => {
+			expect(column.getValueString({ value: 42 })).to.equal('Berlin')
+			response = {}
+		})
+		cy.then(() => store.loadRelationsFromBE({ token, force: true }))
+		cy.then(() => {
+			expect(column.resolveValue(42).status).to.equal('unavailable')
+			expect(column.getValueString({ value: 42 })).to.equal('')
+			expect(store.getRelationsLoading(false, null)).to.equal(false)
+		})
+	})
+})
diff --git a/cypress/component/Relation.cy.js b/cypress/component/Relation.cy.js
new file mode 100644
index 0000000000..ebe8cc43ba
--- /dev/null
+++ b/cypress/component/Relation.cy.js
@@ -0,0 +1,54 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { createPinia, setActivePinia } from 'pinia'
+import { translate as t, translatePlural as n } from '@nextcloud/l10n'
+import { useDataStore } from '../../src/store/data.js'
+import RelationColumn from '../../src/shared/components/ncTable/mixins/columnsTypes/relation.js'
+import TableRow from '../../src/shared/components/ncTable/partials/TableRow.vue'
+
+for (const relationType of ['table', 'view']) {
+	describe(`Relation inline selection (${relationType})`, () => {
+		for (const value of [270, '270']) {
+			it(`shows the selected label for a ${typeof value} row ID`, () => {
+				const pinia = createPinia()
+				setActivePinia(pinia)
+				const store = useDataStore()
+				const column = new RelationColumn({
+					id: 7,
+					tableId: 1,
+					title: 'Approver',
+					customSettings: { relationType, targetId: 2, labelColumn: 20 },
+				})
+				store.relations[7] = {
+					column: null,
+					values: {
+						270: { id: 270, value: 'Alice' },
+						271: { id: 271, value: 'Bob' },
+					},
+					loading: false,
+				}
+				cy.mount(TableRow, {
+					props: {
+						row: { id: 1, data: [{ columnId: 7, value }] },
+						columns: [column],
+						config: { canEditRows: true, canSelectRows: false, showActions: false },
+						isView: false,
+						elementId: 1,
+					},
+					global: {
+						plugins: [pinia],
+						mixins: [{ methods: { t, n } }],
+						config: { globalProperties: { OC: window.OC, OCA: window.OCA } },
+					},
+				})
+				cy.contains('.cell-relation .non-edit-mode', 'Alice').click()
+				cy.get('.cell-relation .edit-mode .vs__selected').should('contain', 'Alice').and('not.contain', '270')
+				cy.get('[aria-label="Select relation value"]').click()
+				cy.get('.vs__dropdown-menu').should('contain', 'Alice').and('contain', 'Bob')
+			})
+		}
+	})
+}
diff --git a/lib/Analytics/AnalyticsDatasource.php b/lib/Analytics/AnalyticsDatasource.php
index 393bf249d4..40e4d50193 100644
--- a/lib/Analytics/AnalyticsDatasource.php
+++ b/lib/Analytics/AnalyticsDatasource.php
@@ -378,10 +378,10 @@ private function formatRelationValue(Column $column, mixed $value): string {
 			return '';
 		}
 
-		$relationData = $this->relationService->getRelationData($column);
+		$relationLabels = $this->relationService->getRelationLabels($column);
 		$valueId = (int)$value;
 
-		return $relationData[$valueId]['label'] ?? (string)$value;
+		return $relationLabels[$valueId]['value'] ?? (string)$value;
 	}
 
 	private function parseDefaultValue(?string $value): mixed {
diff --git a/lib/Constants/ColumnType.php b/lib/Constants/ColumnType.php
index f296de2f74..8d73ecdd54 100644
--- a/lib/Constants/ColumnType.php
+++ b/lib/Constants/ColumnType.php
@@ -16,4 +16,5 @@ enum ColumnType: string {
 	case DATETIME = 'datetime';
 	case PEOPLE = 'usergroup';
 	case RELATION = 'relation';
+	case LOOKUP = 'lookup';
 }
diff --git a/lib/Controller/Api1Controller.php b/lib/Controller/Api1Controller.php
index 1e5984a4d9..20753a9969 100644
--- a/lib/Controller/Api1Controller.php
+++ b/lib/Controller/Api1Controller.php
@@ -53,6 +53,7 @@
  * @psalm-import-type TablesShare from ResponseDefinitions
  * @psalm-import-type TablesColumn from ResponseDefinitions
  * @psalm-import-type TablesRow from ResponseDefinitions
+ * @psalm-import-type TablesRelationData from ResponseDefinitions
  * @psalm-import-type TablesImportState from ResponseDefinitions
  * @psalm-import-type TablesContextNavigation from ResponseDefinitions
  */
@@ -831,7 +832,7 @@ public function indexViewColumns(int $viewId): DataResponse {
 	 * Get all relation data for a table
 	 *
 	 * @param int $tableId Table ID
-	 * @return DataResponse<Http::STATUS_OK, array<string, array<string, array{id: int, label: string}>>, array{}>|DataResponse<Http::STATUS_FORBIDDEN|Http::STATUS_INTERNAL_SERVER_ERROR|Http::STATUS_NOT_FOUND, array{message: string}, array{}>
+	 * @return DataResponse<Http::STATUS_OK, TablesRelationData, array{}>|DataResponse<Http::STATUS_FORBIDDEN|Http::STATUS_INTERNAL_SERVER_ERROR|Http::STATUS_NOT_FOUND, array{message: string}, array{}>
 	 *
 	 * 200: Relation data returned
 	 * 403: No permissions
@@ -841,6 +842,7 @@ public function indexViewColumns(int $viewId): DataResponse {
 	#[NoCSRFRequired]
 	#[CORS]
 	#[RequirePermission(permission: Application::PERMISSION_READ, type: Application::NODE_TYPE_TABLE, idParam: 'tableId')]
+	#[OpenAPI(scope: OpenAPI::SCOPE_DEFAULT)]
 	public function indexTableRelations(int $tableId): DataResponse {
 		try {
 			return new DataResponse($this->relationService->getRelationsForTable($tableId));
@@ -863,7 +865,7 @@ public function indexTableRelations(int $tableId): DataResponse {
 	 * Get all relation data for a view
 	 *
 	 * @param int $viewId View ID
-	 * @return DataResponse<Http::STATUS_OK, array<string, array<string, array{id: int, label: string}>>, array{}>|DataResponse<Http::STATUS_FORBIDDEN|Http::STATUS_INTERNAL_SERVER_ERROR|Http::STATUS_NOT_FOUND, array{message: string}, array{}>
+	 * @return DataResponse<Http::STATUS_OK, TablesRelationData, array{}>|DataResponse<Http::STATUS_FORBIDDEN|Http::STATUS_INTERNAL_SERVER_ERROR|Http::STATUS_NOT_FOUND, array{message: string}, array{}>
 	 *
 	 * 200: Relation data returned
 	 * 403: No permissions
@@ -873,6 +875,7 @@ public function indexTableRelations(int $tableId): DataResponse {
 	#[NoCSRFRequired]
 	#[CORS]
 	#[RequirePermission(permission: Application::PERMISSION_READ, type: Application::NODE_TYPE_VIEW, idParam: 'viewId')]
+	#[OpenAPI(scope: OpenAPI::SCOPE_DEFAULT)]
 	public function indexViewRelations(int $viewId): DataResponse {
 		try {
 			return new DataResponse($this->relationService->getRelationsForView($viewId));
@@ -897,7 +900,7 @@ public function indexViewRelations(int $viewId): DataResponse {
 	 * @param int|null $tableId Table ID
 	 * @param int|null $viewId View ID
 	 * @param string $title Title
-	 * @param 'text'|'number'|'datetime'|'select'|'usergroup'|'relation' $type Column main type
+	 * @param 'text'|'number'|'datetime'|'select'|'usergroup'|'relation'|'lookup' $type Column main type
 	 * @param string|null $technicalName Technical name of the column
 	 * @param string|null $subtype Column sub type
 	 * @param bool $mandatory Is the column mandatory
@@ -1057,7 +1060,7 @@ public function createColumn(
 	 * @param bool|null $usergroupSelectGroups Can select groups, if column type is usergroup
 	 * @param bool|null $usergroupSelectTeams Can select teams, if column type is usergroup
 	 * @param bool|null $usergroupShowUserStatus Whether to show the user's status, if column type is usergroup
-	 * @param array<string, mixed> $customSettings Custom settings for the column
+	 * @param array<string, mixed>|null $customSettings Custom settings for the column
 	 *
 	 * @return DataResponse<Http::STATUS_OK, TablesColumn, array{}>|DataResponse<Http::STATUS_BAD_REQUEST|Http::STATUS_INTERNAL_SERVER_ERROR, array{message: string}, array{}>
 	 *
@@ -1100,7 +1103,7 @@ public function updateColumn(
 		?bool $usergroupSelectGroups,
 		?bool $usergroupSelectTeams,
 		?bool $usergroupShowUserStatus,
-		?array $customSettings = [],
+		?array $customSettings = null,
 	): DataResponse {
 		try {
 			$item = $this->columnService->update(
@@ -1131,7 +1134,7 @@ public function updateColumn(
 					usergroupSelectGroups: $usergroupSelectGroups,
 					usergroupSelectTeams: $usergroupSelectTeams,
 					showUserStatus: $usergroupShowUserStatus,
-					customSettings: json_encode($customSettings),
+					customSettings: $customSettings !== null ? json_encode($customSettings) : null,
 				)
 			);
 			return new DataResponse($item->jsonSerialize());
@@ -1681,7 +1684,7 @@ public function createTableShare(int $tableId, string $receiver, string $receive
 	 *
 	 * @param int $tableId Table ID
 	 * @param string $title Title
-	 * @param 'text'|'number'|'datetime'|'select'|'usergroup'|'relation' $type Column main type
+	 * @param 'text'|'number'|'datetime'|'select'|'usergroup'|'relation'|'lookup' $type Column main type
 	 * @param string|null $technicalName Technical name of the column
 	 * @param string|null $subtype Column sub type
 	 * @param bool $mandatory Is the column mandatory
diff --git a/lib/Db/Column.php b/lib/Db/Column.php
index a039dd33c7..7aa475f7f2 100644
--- a/lib/Db/Column.php
+++ b/lib/Db/Column.php
@@ -107,6 +107,7 @@ class Column extends EntitySuper implements JsonSerializable {
 	public const TYPE_DATETIME = 'datetime';
 	public const TYPE_USERGROUP = 'usergroup';
 	public const TYPE_RELATION = 'relation';
+	public const TYPE_LOOKUP = 'lookup';
 
 	public const SUBTYPE_DATETIME_DATE = 'date';
 	public const SUBTYPE_DATETIME_TIME = 'time';
@@ -354,6 +355,28 @@ public function getCustomSettingsArray(): array {
 		return json_decode((string)$this->customSettings, true) ?: [];
 	}
 
+	/**
+	 * @template T
+	 * @param class-string<T> $className
+	 * @return T
+	 * @throws \InvalidArgumentException
+	 */
+	public function getCustomSettingsObject(string $className): mixed {
+		$array = $this->getCustomSettingsArray();
+		if (method_exists($className, 'fromArray')) {
+			return $className::fromArray($array);
+		}
+		throw new \InvalidArgumentException("Class $className must have a fromArray method");
+	}
+
+	/**
+	 * Virtual columns do not store their own cell data,
+	 * their values are derived from a related column.
+	 */
+	public function isVirtual(): bool {
+		return $this->type === self::TYPE_LOOKUP;
+	}
+
 	/**
 	 * @throws ValueError
 	 */
diff --git a/lib/Db/Row2Mapper.php b/lib/Db/Row2Mapper.php
index aeb7c59c8c..dba7faafd1 100644
--- a/lib/Db/Row2Mapper.php
+++ b/lib/Db/Row2Mapper.php
@@ -10,6 +10,7 @@
 use DateTime;
 use DateTimeImmutable;
 use OCA\Tables\Constants\UsergroupType;
+use OCA\Tables\Dto\LookupSettings;
 use OCA\Tables\Errors\InternalError;
 use OCA\Tables\Errors\NotFoundError;
 use OCA\Tables\Helper\ColumnsHelper;
@@ -52,6 +53,9 @@ public function delete(Row2 $row): Row2 {
 		$this->db->beginTransaction();
 		try {
 			foreach ($this->columnsHelper->columns as $columnType) {
+				if ($this->isVirtualColumn($columnType)) {
+					continue;
+				}
 				$this->getCellMapperFromType($columnType)->deleteAllForRow($row->getId());
 			}
 			$this->rowSleeveMapper->deleteById($row->getId());
@@ -73,7 +77,7 @@ public function delete(Row2 $row): Row2 {
 	 * @throws NotFoundError
 	 */
 	public function find(int $id, array $columns): Row2 {
-		$columnIdsArray = array_map(fn (Column $column) => $column->getId(), $columns);
+		$columnIdsArray = $this->getColumnIdsWithRelationColumns($columns);
 		$rows = $this->getRows([$id], $columnIdsArray);
 
 		if (count($rows) === 1) {
@@ -172,6 +176,7 @@ private function getWantedRowIds(string $userId, int $tableId, ?array $filter =
 	 */
 	public function findAll(array $showColumnIds, int $tableId, ?int $limit = null, ?int $offset = null, ?array $filter = null, ?array $sort = null, ?string $userId = null): array {
 		try {
+			$showColumnIds = $this->getColumnIdsWithRelationColumns($this->columnMapper->findAll($showColumnIds));
 			$this->columnMapper->preloadColumns($showColumnIds, $filter, $sort);
 
 			$wantedRowIdsArray = $this->getWantedRowIds($userId, $tableId, $filter, $sort, $limit, $offset);
@@ -214,8 +219,12 @@ private function getRows(array $rowIds, array $columnIds): array {
 	private function getRowsChunk(array $rowIds, array $columnIds): array {
 		$qb = $this->db->getQueryBuilder();
 
+		$columnFilter = $qb->expr()->in('column_id', $qb->createNamedParameter($columnIds, IQueryBuilder::PARAM_INT_ARRAY, ':columnIds'));
 		$qbSqlForColumnTypes = null;
 		foreach ($this->columnsHelper->columns as $columnType) {
+			if ($this->isVirtualColumn($columnType)) {
+				continue;
+			}
 			$qbTmp = $this->db->getQueryBuilder();
 			$qbTmp->select('row_id', 'column_id', 'last_edit_at', 'last_edit_by')
 				->selectAlias($qb->expr()->castColumn('value', IQueryBuilder::PARAM_STR), 'value');
@@ -231,7 +240,7 @@ private function getRowsChunk(array $rowIds, array $columnIds): array {
 
 			$qbTmp
 				->from('tables_row_cells_' . $columnType)
-				->where($qb->expr()->in('column_id', $qb->createNamedParameter($columnIds, IQueryBuilder::PARAM_INT_ARRAY, ':columnIds')))
+				->where($columnFilter)
 				->andWhere($qb->expr()->in('row_id', $qb->createNamedParameter($rowIds, IQueryBuilder::PARAM_INT_ARRAY, ':rowsIds')));
 
 			if ($qbSqlForColumnTypes) {
@@ -304,6 +313,10 @@ private function addSortQueryForMultipleSleeveFinder(IQueryBuilder $qb, string $
 				continue;
 			}
 
+			if ($column && $column->isVirtual()) {
+				continue;
+			}
+
 			// if is normal column
 			if ($sortData['columnId'] >= 0) {
 				$valueTable = 'tables_row_cells_' . $column->getType();
@@ -892,6 +905,10 @@ private function insertCell(int $rowId, int $columnId, $value, ?string $lastEdit
 			throw new InternalError(static::class . ' - ' . __FUNCTION__ . ': ' . $e->getMessage());
 		}
 
+		if ($column->isVirtual()) {
+			return;
+		}
+
 		// insert new cell
 		$cellMapper = $this->getCellMapper($column);
 
@@ -930,6 +947,10 @@ private function insertCell(int $rowId, int $columnId, $value, ?string $lastEdit
 	 * @throws InternalError
 	 */
 	private function updateCell(RowCellSuper $cell, RowCellMapperSuper $mapper, $value, Column $column): void {
+		if ($column->isVirtual()) {
+			return;
+		}
+
 		$this->getCellMapper($column)->applyDataToEntity($column, $cell, $value);
 		$this->updateMetaData($cell);
 		$mapper->updateWrapper($cell);
@@ -940,6 +961,9 @@ private function updateCell(RowCellSuper $cell, RowCellMapperSuper $mapper, $val
 	 */
 	private function insertOrUpdateCell(int $rowId, int $columnId, $value): void {
 		$column = $this->columnMapper->find($columnId);
+		if ($column->isVirtual()) {
+			return;
+		}
 		$cellMapper = $this->getCellMapper($column);
 		try {
 			if ($cellMapper->hasMultipleValues()) {
@@ -966,6 +990,9 @@ private function getCellMapper(Column $column): RowCellMapperSuper {
 	}
 
 	private function getCellMapperFromType(string $columnType): RowCellMapperSuper {
+		if ($this->isVirtualColumn($columnType)) {
+			throw new InternalError('Virtual columns do not have cell mappers');
+		}
 		$cellMapperClassName = 'OCA\Tables\Db\RowCell' . ucfirst($columnType) . 'Mapper';
 		/** @var RowCellMapperSuper $cellMapper */
 		try {
@@ -987,6 +1014,9 @@ private function getColumnDbParamType(Column $column): int {
 	 * @throws InternalError
 	 */
 	public function deleteDataForColumn(Column $column): void {
+		if ($column->isVirtual()) {
+			return;
+		}
 		try {
 			$this->getCellMapper($column)->deleteAllForColumn($column->getId());
 		} catch (Exception $e) {
@@ -1067,6 +1097,7 @@ private function getFormattedDefaultValue(Column $column) {
 			Column::TYPE_NUMBER => $this->getCellMapper($column)->filterValueToQueryParam($column, $column->getNumberDefault()),
 			Column::TYPE_TEXT => $this->getCellMapper($column)->filterValueToQueryParam($column, $column->getTextDefault()),
 			Column::TYPE_USERGROUP => $this->getCellMapper($column)->filterValueToQueryParam($column, $column->getUsergroupDefault()),
+			Column::TYPE_LOOKUP => null,
 			default => $defaultValue,
 		};
 		return $defaultValue;
@@ -1095,4 +1126,34 @@ private function sortRowsByIds(array $rows, array $wantedRowIds): array {
 
 		return $sortedRows;
 	}
+
+	public function isVirtualColumn(string $columnType): bool {
+		return $columnType === Column::TYPE_LOOKUP;
+	}
+
+	/**
+	 * Maps columns to their IDs and adds the relation column ID for each lookup
+	 * column, so the cells of the underlying relation column get fetched too.
+	 *
+	 * @param Column[] $columns
+	 * @return int[]
+	 */
+	public function getColumnIdsWithRelationColumns(array $columns): array {
+		$columnIds = [];
+		foreach ($columns as $column) {
+			$columnIds[] = $column->getId();
+			if (!$column->isVirtual()) {
+				continue;
+			}
+
+			try {
+				$settings = $column->getCustomSettingsObject(LookupSettings::class);
+				$columnIds[] = $settings->relationColumnId;
+			} catch (\InvalidArgumentException $e) {
+				$this->logger->warning('Invalid lookup settings for column ' . $column->getId(), ['exception' => $e]);
+			}
+		}
+		return array_values(array_unique(array_filter($columnIds)));
+	}
+
 }
diff --git a/lib/Dto/LookupSettings.php b/lib/Dto/LookupSettings.php
new file mode 100644
index 0000000000..d9411701e0
--- /dev/null
+++ b/lib/Dto/LookupSettings.php
@@ -0,0 +1,39 @@
+<?php
+
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+namespace OCA\Tables\Dto;
+
+readonly class LookupSettings {
+	public function __construct(
+		public int $relationColumnId,
+		public int $targetColumnId,
+	) {
+		if ($relationColumnId <= 0 || $targetColumnId <= 0) {
+			throw new \InvalidArgumentException('Lookup relation and target column IDs must be positive integers.');
+		}
+	}
+
+	public static function fromArray(array $data): self {
+		return new self(
+			relationColumnId: self::parseIntField($data['relationColumnId'] ?? null, 'relationColumnId'),
+			targetColumnId: self::parseIntField($data['targetColumnId'] ?? null, 'targetColumnId'),
+		);
+	}
+
+	/**
+	 * Settings may arrive as form parameters, where integers are encoded as strings.
+	 */
+	private static function parseIntField(mixed $value, string $field): int {
+		if (is_string($value) && ctype_digit($value)) {
+			$value = (int)$value;
+		}
+		if (!is_int($value)) {
+			throw new \InvalidArgumentException($field . ' must be an integer.');
+		}
+		return $value;
+	}
+}
diff --git a/lib/Dto/RelationSettings.php b/lib/Dto/RelationSettings.php
new file mode 100644
index 0000000000..d1137fc505
--- /dev/null
+++ b/lib/Dto/RelationSettings.php
@@ -0,0 +1,51 @@
+<?php
+
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+namespace OCA\Tables\Dto;
+
+readonly class RelationSettings {
+	public function __construct(
+		public string $relationType,
+		public int $targetId,
+		public int $labelColumn,
+	) {
+		if (!in_array($relationType, ['table', 'view'], true)) {
+			throw new \InvalidArgumentException('Relation type must be table or view.');
+		}
+		if ($targetId <= 0 || $labelColumn <= 0) {
+			throw new \InvalidArgumentException('Relation target and label column IDs must be positive integers.');
+		}
+	}
+
+	public static function fromArray(array $data): self {
+		if (!isset($data['relationType']) || !is_string($data['relationType'])) {
+			throw new \InvalidArgumentException('Relation type is required.');
+		}
+		return new self(
+			relationType: $data['relationType'],
+			targetId: self::parseIntField($data['targetId'] ?? null, 'targetId'),
+			labelColumn: self::parseIntField($data['labelColumn'] ?? null, 'labelColumn'),
+		);
+	}
+
+	/**
+	 * Settings may arrive as form parameters, where integers are encoded as strings.
+	 */
+	private static function parseIntField(mixed $value, string $field): int {
+		if (is_string($value) && ctype_digit($value)) {
+			$value = (int)$value;
+		}
+		if (!is_int($value)) {
+			throw new \InvalidArgumentException($field . ' must be an integer.');
+		}
+		return $value;
+	}
+
+	public function isView(): bool {
+		return $this->relationType === 'view';
+	}
+}
diff --git a/lib/Helper/ColumnsHelper.php b/lib/Helper/ColumnsHelper.php
index 2ebe0e254d..d05be27db2 100644
--- a/lib/Helper/ColumnsHelper.php
+++ b/lib/Helper/ColumnsHelper.php
@@ -21,6 +21,7 @@ class ColumnsHelper {
 		Column::TYPE_SELECTION,
 		Column::TYPE_USERGROUP,
 		Column::TYPE_RELATION,
+		Column::TYPE_LOOKUP,
 	];
 
 	/**
diff --git a/lib/ResponseDefinitions.php b/lib/ResponseDefinitions.php
index 194aa0a24a..19b3becdc0 100644
--- a/lib/ResponseDefinitions.php
+++ b/lib/ResponseDefinitions.php
@@ -169,9 +169,14 @@
  *     mandatory: bool,
  *  },
  *  customSettings: ?array{
- *     width: int,
+ *     width?: int,
  *     showPreview?: bool,
  *     imagePreviewSize?: int,
+ *     relationType?: 'table'|'view',
+ *     targetId?: int,
+ *     labelColumn?: int,
+ *     relationColumnId?: int,
+ *     targetColumnId?: int,
  *  },
  * }
  *
@@ -212,9 +217,14 @@
  *      mandatory: bool,
  *   },
  *   customSettings: ?array{
- *      width: int,
+ *      width?: int,
  *      showPreview?: bool,
  *      imagePreviewSize?: int,
+ *      relationType?: 'table'|'view',
+ *      targetId?: int,
+ *      labelColumn?: int,
+ *      relationColumnId?: int,
+ *      targetColumnId?: int,
  *   },
  *  }
  *
@@ -249,6 +259,9 @@
  *     notify-column: bool,
  *     notify-row: bool,
  * }
+ *
+ * @psalm-type TablesRelationValue = string|int|float|bool|null|list<int|string>|list<array{id: string, type: int, displayName: string}>
+ * @psalm-type TablesRelationData = array<string, array{column: ?TablesColumn, values: array<string, array{id: int, value: TablesRelationValue}>|list<empty>}>|list<empty>
  */
 class ResponseDefinitions {
 }
diff --git a/lib/Service/ColumnService.php b/lib/Service/ColumnService.php
index 7bb5c79d59..dd6fff32d4 100644
--- a/lib/Service/ColumnService.php
+++ b/lib/Service/ColumnService.php
@@ -16,13 +16,17 @@
 use OCA\Tables\Db\Table;
 use OCA\Tables\Db\TableMapper;
 use OCA\Tables\Db\View;
+use OCA\Tables\Db\ViewMapper;
 use OCA\Tables\Dto\Column as ColumnDto;
+use OCA\Tables\Dto\LookupSettings;
+use OCA\Tables\Dto\RelationSettings;
 use OCA\Tables\Errors\BadRequestError;
 use OCA\Tables\Errors\InternalError;
 use OCA\Tables\Errors\NotFoundError;
 use OCA\Tables\Errors\PermissionError;
 use OCA\Tables\Helper\UserHelper;
 use OCA\Tables\Model\SelectionOptions;
+use OCA\Tables\Model\SortRuleSet;
 use OCA\Tables\Notification\NotificationHelper;
 use OCA\Tables\ResponseDefinitions;
 use OCA\Tables\Service\ValueObject\Title;
@@ -54,6 +58,7 @@ public function __construct(
 		private readonly IL10N $l,
 		private readonly UserHelper $userHelper,
 		private readonly ColumnDtoValidator $columnDtoValidator,
+		private readonly ViewMapper $viewMapper,
 	) {
 		parent::__construct($logger, $userId, $permissionsService);
 	}
@@ -294,6 +299,7 @@ public function create(
 		$item = Column::fromDto($columnDto);
 		$item->setTitle($newTitle);
 		$item->setTableId($table->getId());
+		$this->validateRelationSettings($item);
 		$this->updateMetadata($item, $userId, true);
 
 		try {
@@ -423,7 +429,10 @@ public function update(
 			$item->setUsergroupSelectTeams($columnDto->getUsergroupSelectTeams());
 			$item->setShowUserStatus($columnDto->getShowUserStatus());
 			$this->validateCustomSettings($columnDto->getCustomSettings());
-			$item->setCustomSettings($columnDto->getCustomSettings());
+			if ($columnDto->getCustomSettings() !== null) {
+				$item->setCustomSettings($columnDto->getCustomSettings());
+			}
+			$this->validateRelationSettings($item);
 
 			$this->updateMetadata($item, $userId);
 			try {
@@ -507,6 +516,55 @@ private function validateCustomSettings(?string $customSettings): void {
 		}
 	}
 
+	private function validateRelationSettings(Column $column): void {
+		try {
+			if ($column->getType() === Column::TYPE_RELATION) {
+				$settings = $column->getCustomSettingsObject(RelationSettings::class);
+				$label = $this->mapper->find($settings->labelColumn);
+				$this->assertRelationTargetColumn($settings, $label);
+				if (!(($label->getType() === Column::TYPE_TEXT && $label->getSubtype() === 'line')
+					|| ($label->getType() === Column::TYPE_NUMBER && $label->getSubtype() === ''))) {
+					throw new \InvalidArgumentException('Relation labels must use a text-line or number column.');
+				}
+			}
+			if ($column->getType() !== Column::TYPE_LOOKUP) {
+				return;
+			}
+			if ($column->getMandatory()) {
+				throw new \InvalidArgumentException('Lookup columns cannot be mandatory.');
+			}
+			$settings = $column->getCustomSettingsObject(LookupSettings::class);
+			$relation = $this->mapper->find($settings->relationColumnId);
+			if ($relation->getType() !== Column::TYPE_RELATION || $relation->getTableId() !== $column->getTableId()) {
+				throw new \InvalidArgumentException('Lookup relation must be a relation column in the same table.');
+			}
+			$target = $this->mapper->find($settings->targetColumnId);
+			$this->assertRelationTargetColumn($relation->getCustomSettingsObject(RelationSettings::class), $target);
+			if (in_array($target->getType(), [Column::TYPE_RELATION, Column::TYPE_LOOKUP], true)) {
+				throw new \InvalidArgumentException('Lookup targets cannot be relation or lookup columns.');
+			}
+		} catch (\InvalidArgumentException|DoesNotExistException $e) {
+			throw new BadRequestError($e->getMessage(), 0, $e);
+		}
+	}
+
+	public function assertRelationTargetColumn(RelationSettings $settings, Column $column): void {
+		$view = $settings->isView() ? $this->viewMapper->find($settings->targetId) : null;
+		$tableId = $view ? $view->getTableId() : $settings->targetId;
+		if ($column->getTableId() !== $tableId || ($view && !in_array($column->getId(), $view->getColumnIds(), true))) {
+			throw new \InvalidArgumentException('Column must belong to the relation target table or view.');
+		}
+	}
+
+	public function validateSortRules(SortRuleSet $sort): void {
+		$columnIds = array_filter(array_column($sort->jsonSerialize(), 'columnId'), fn (int $id) => $id > 0);
+		foreach ($this->mapper->findAll($columnIds) as $column) {
+			if ($column->isVirtual()) {
+				throw new \InvalidArgumentException('Lookup columns cannot be used in saved sorting rules.');
+			}
+		}
+	}
+
 	private function normalizeTitle(?string $title, bool $required): ?string {
 		if ($title === null) {
 			if ($required) {
@@ -652,6 +710,11 @@ public function findOrCreateColumnsByTitleForTableAsArray(?int $tableId, ?int $v
 		foreach ($titles as $title) {
 			$i++;
 			foreach ($allColumns as $column) {
+				// Skip matching columns with type lookup
+				if ($column->isVirtual()) {
+					continue;
+				}
+
 				if ($column->getTitle() === $title) {
 					$result[$i] = $column;
 					$countMatchingColumns++;
diff --git a/lib/Service/ColumnTypes/LookupBusiness.php b/lib/Service/ColumnTypes/LookupBusiness.php
new file mode 100644
index 0000000000..9b3c7648a6
--- /dev/null
+++ b/lib/Service/ColumnTypes/LookupBusiness.php
@@ -0,0 +1,58 @@
+<?php
+
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+namespace OCA\Tables\Service\ColumnTypes;
+
+use OCA\Tables\Db\Column;
+
+class LookupBusiness extends SuperBusiness {
+	/**
+	 * @param mixed $value (array|string|null)
+	 * @param Column|null $column
+	 * @return string
+	 */
+	public function parseValue($value, ?Column $column = null): string {
+		// Lookup is a virtual column, values come from the related table
+		// No parsing needed for input as this column is read-only
+		return '';
+	}
+
+	/**
+	 * @param mixed $value (array|string|null)
+	 * @param Column|null $column
+	 * @return bool
+	 */
+	public function canBeParsed($value, ?Column $column = null): bool {
+		// Virtual column, cannot be set directly
+		return false;
+	}
+
+	public function validateValue(mixed $value, Column $column, string $userId, int $tableId, ?int $rowId): void {
+		// Virtual column, validation not applicable
+		// Values are derived from the relation column
+	}
+
+	/**
+	 * @param mixed $value
+	 * @param Column $column
+	 * @return bool
+	 */
+	public function canBeParsedDisplayValue($value, Column $column): bool {
+		// Virtual column, display values come from relation data
+		return false;
+	}
+
+	/**
+	 * @param mixed $value
+	 * @param Column $column
+	 * @return string
+	 */
+	public function parseDisplayValue($value, Column $column): string {
+		// Virtual column, display values come from relation data
+		return '';
+	}
+}
diff --git a/lib/Service/ColumnTypes/RelationBusiness.php b/lib/Service/ColumnTypes/RelationBusiness.php
index f072904cd5..c0c1045d2d 100644
--- a/lib/Service/ColumnTypes/RelationBusiness.php
+++ b/lib/Service/ColumnTypes/RelationBusiness.php
@@ -12,7 +12,7 @@
 use OCA\Tables\Service\RelationService;
 use Psr\Log\LoggerInterface;
 
-class RelationBusiness extends SuperBusiness implements IColumnTypeBusiness {
+class RelationBusiness extends SuperBusiness {
 
 	public function __construct(
 		LoggerInterface $logger,
@@ -33,15 +33,15 @@ public function parseValue($value, ?Column $column = null): string|false {
 			return '';
 		}
 
-		$relationData = $this->relationService->getRelationData($column);
+		$relationLabels = $this->relationService->getRelationLabels($column);
 		// try to find value by label
-		$matchingRelation = array_filter($relationData, fn (array $relation) => $relation['label'] === $value);
+		$matchingRelation = array_filter($relationLabels, fn (array $relation) => $relation['value'] === $value);
 		if (!empty($matchingRelation)) {
 			return json_encode(reset($matchingRelation)['id']);
 		}
 
 		// if not found, try to find by id
-		if (is_numeric($value) && isset($relationData[(int)$value])) {
+		if (is_numeric($value) && isset($relationLabels[(int)$value])) {
 			return json_encode($value);
 		}
 
@@ -62,14 +62,14 @@ public function canBeParsed($value, ?Column $column = null): bool {
 			return true;
 		}
 
-		$relationData = $this->relationService->getRelationData($column);
+		$relationLabels = $this->relationService->getRelationLabels($column);
 		// try to find value by label
-		$matchingRelation = array_filter($relationData, fn (array $relation) => $relation['label'] === $value);
+		$matchingRelation = array_filter($relationLabels, fn (array $relation) => $relation['value'] === $value);
 		if (!empty($matchingRelation)) {
 			return true;
 		}
 		// if not found, try to find by id
-		if (is_numeric($value) && isset($relationData[(int)$value])) {
+		if (is_numeric($value) && isset($relationLabels[(int)$value])) {
 			return true;
 		}
 
@@ -81,16 +81,16 @@ public function validateValue(mixed $value, Column $column, string $userId, int
 			return;
 		}
 		// Validate that the value exists in the target table/view
-		$relationData = $this->relationService->getRelationData($column);
+		$relationLabels = $this->relationService->getRelationLabels($column);
 
 		// Try to find value by label first
-		$matchingRelation = array_filter($relationData, fn (array $relation) => $relation['label'] === $value);
+		$matchingRelation = array_filter($relationLabels, fn (array $relation) => $relation['value'] === $value);
 		if (!empty($matchingRelation)) {
 			return;
 		}
 
 		// If not found by label, try to find by id
-		if (is_numeric($value) && isset($relationData[(int)$value])) {
+		if (is_numeric($value) && isset($relationLabels[(int)$value])) {
 			return;
 		}
 
diff --git a/lib/Service/RelationService.php b/lib/Service/RelationService.php
index 6d0ca9fade..5239cc4d06 100644
--- a/lib/Service/RelationService.php
+++ b/lib/Service/RelationService.php
@@ -9,23 +9,37 @@
 
 use OCA\Tables\Db\Column;
 use OCA\Tables\Db\ColumnMapper;
+use OCA\Tables\Db\Row2;
 use OCA\Tables\Db\Row2Mapper;
 use OCA\Tables\Db\ViewMapper;
+use OCA\Tables\Dto\LookupSettings;
+use OCA\Tables\Dto\RelationSettings;
 use OCA\Tables\Errors\InternalError;
 use OCA\Tables\Errors\NotFoundError;
 use OCA\Tables\Errors\PermissionError;
+use OCA\Tables\ResponseDefinitions;
 use OCP\AppFramework\Db\DoesNotExistException;
+use OCP\IUserSession;
+use Psr\Log\LoggerInterface;
 
+/**
+ * @psalm-import-type TablesColumn from ResponseDefinitions
+ * @psalm-import-type TablesPublicColumn from ResponseDefinitions
+ * @psalm-import-type TablesRelationData from ResponseDefinitions
+ * @psalm-import-type TablesRelationValue from ResponseDefinitions
+ */
 class RelationService {
-	/** @var array<string, array> Cache for relation data */
-	private array $cacheRelationData = [];
+	/** @var array<string, array> Cache for formatted relation labels */
+	private array $cacheRelationLabels = [];
+	private array $cacheRawRelationData = [];
 
 	public function __construct(
 		private readonly ColumnMapper $columnMapper,
 		private readonly ViewMapper $viewMapper,
 		private readonly Row2Mapper $row2Mapper,
 		private readonly ColumnService $columnService,
-		private readonly ?string $userId,
+		private readonly IUserSession $userSession,
+		private readonly LoggerInterface $logger,
 	) {
 	}
 
@@ -33,55 +47,92 @@ public function __construct(
 	 * Get all relation data for a table
 	 *
 	 * @param int $tableId
-	 * @return array Relation data grouped by column ID
+	 * @return TablesRelationData Relation data grouped by column ID
 	 * @throws InternalError
 	 * @throws NotFoundError
 	 * @throws PermissionError
 	 */
-	public function getRelationsForTable(int $tableId): array {
+	public function getRelationsForTable(int $tableId, ?string $userId = null): array {
 		// Check table permissions through ColumnService
-		$columns = $this->columnService->findAllByTable($tableId);
-
-		$relationColumns = array_filter($columns, fn ($column) => $column->getType() === Column::TYPE_RELATION);
+		$columns = $this->columnService->findAllByTable($tableId, $userId);
 
-		return $this->getRelationsForColumns($relationColumns);
+		return $this->getRelationsForColumnList($columns);
 	}
 
 	/**
 	 * Get all relation data for a view
 	 *
 	 * @param int $viewId
-	 * @return array Relation data grouped by column ID
+	 * @return TablesRelationData Relation data grouped by column ID
 	 * @throws InternalError
 	 * @throws NotFoundError
 	 * @throws PermissionError
 	 */
-	public function getRelationsForView(int $viewId): array {
+	public function getRelationsForView(int $viewId, ?string $userId = null): array {
 		// Check view permissions through ColumnService
-		$columns = $this->columnService->findAllByView($viewId);
+		$columns = $this->columnService->findAllByView($viewId, $userId);
 
-		$relationColumns = array_filter($columns, fn ($column) => $column->getType() === Column::TYPE_RELATION);
+		return $this->getRelationsForColumnList($columns);
+	}
 
-		return $this->getRelationsForColumns($relationColumns);
+	/**
+	 * Get relation labels for a specific column
+	 *
+	 * @param Column $column
+	 * @return array<int, array{id: int, value: string}> Indexed per row id
+	 */
+	public function getRelationLabels(Column $column): array {
+		if ($column->getType() !== Column::TYPE_RELATION) {
+			return [];
+		}
+
+		try {
+			return $this->fetchRelationLabelsForTarget($column);
+		} catch (\InvalidArgumentException $e) {
+			$this->logger->warning('Invalid relation settings for column ' . $column->getId() . ': ' . $e->getMessage());
+			return [];
+		}
 	}
 
 	/**
-	 * Get relation data for specific columns
+	 * Get relation data for a list of columns
 	 *
-	 * @param Column[] $relationColumns
-	 * @return array Relation data grouped by column ID
+	 * @param Column[] $columns
+	 * @return TablesRelationData Relation data grouped by column ID
 	 * @throws InternalError
 	 */
-	private function getRelationsForColumns(array $relationColumns): array {
-		// Group columns by their target (relationType + targetId + labelColumn)
+	private function getRelationsForColumnList(array $columns): array {
+		$columnsMap = $this->fetchColumnsByIds($this->collectRelationColumnIds($columns));
+		foreach ($columns as $column) {
+			$columnsMap[$column->getId()] = $column;
+		}
+		$relationColumns = array_filter($columns, fn (Column $column) => $column->getType() === Column::TYPE_RELATION);
+		$lookupColumns = array_filter($columns, fn (Column $column) => $column->getType() === Column::TYPE_LOOKUP);
+		$this->preloadRelationValues($relationColumns, $lookupColumns, $columnsMap);
+		$relationLabels = $this->fetchRelationLabelsForColumns($relationColumns);
+		$lookupData = $this->fetchLookupColumns($lookupColumns, $columnsMap);
+
+		return array_map(
+			fn (array $data) => ['column' => null, 'values' => $data],
+			$relationLabels
+		) + $lookupData;
+	}
+
+	/**
+	 * Fetch relation labels for relation columns
+	 *
+	 * @param Column[] $columns
+	 * @return array<int, array<int, array{id: int, value: string}>> Relation labels, indexed per column ID and row ID
+	 * @throws InternalError
+	 */
+	private function fetchRelationLabelsForColumns(array $columns): array {
 		$result = [];
-		$groupedColumns = $this->groupColumnsByTarget($relationColumns);
-		foreach ($groupedColumns as $target => $columns) {
-			$relationData = $this->getRelationDataForTarget($target, $columns[0]);
 
-			// Assign the same data to all columns with this target
-			foreach ($columns as $column) {
-				$result[$column->getId()] = $relationData;
+		foreach ($columns as $column) {
+			try {
+				$result[$column->getId()] = $this->fetchRelationLabelsForTarget($column);
+			} catch (\InvalidArgumentException $e) {
+				$this->logger->warning('Invalid relation settings for column ' . $column->getId() . ': ' . $e->getMessage());
 			}
 		}
 
@@ -89,117 +140,330 @@ private function getRelationsForColumns(array $relationColumns): array {
 	}
 
 	/**
-	 * Group relation columns by their target configuration
+	 * Fetch relation data for lookup columns
 	 *
 	 * @param Column[] $columns
-	 * @return array
+	 * @param array<int, Column> $columnsMap
+	 * @return TablesRelationData Relation data grouped by column ID
+	 * @throws InternalError
 	 */
-	private function groupColumnsByTarget(array $columns): array {
-		$groups = [];
+	private function fetchLookupColumns(array $columns, array $columnsMap): array {
+		$result = [];
 
+		// Reuse the batch-fetched columns to avoid duplicate queries
 		foreach ($columns as $column) {
-			$settings = $column->getCustomSettingsArray();
-			if (empty($settings['relationType']) || empty($settings['targetId']) || empty($settings['labelColumn'])) {
-				continue;
+			$result[$column->getId()] = ['column' => null, 'values' => []];
+			try {
+				[$settings, $targetColumn] = $this->resolveLookupTarget($column, $columnsMap);
+				$lookupSettings = $column->getCustomSettingsObject(LookupSettings::class);
+				$result[$column->getId()] = [
+					'column' => $targetColumn->jsonSerialize(),
+					'values' => $this->fetchRawRelationValues($settings, $lookupSettings->targetColumnId),
+				];
+			} catch (\InvalidArgumentException|DoesNotExistException $e) {
+				$this->logger->warning('Invalid lookup settings for column ' . $column->getId() . ': ' . $e->getMessage());
+			}
+		}
+
+		return $result;
+	}
+
+	private function getCurrentUserId(): string {
+		return $this->userSession->getUser()?->getUID() ?? '';
+	}
+
+	/**
+	 * @param Column[] $relationColumns
+	 * @param Column[] $lookupColumns
+	 * @param array<int, Column> $columnsMap
+	 */
+	private function preloadRelationValues(array $relationColumns, array $lookupColumns, array $columnsMap): void {
+		$targets = [];
+		foreach ([...$relationColumns, ...$lookupColumns] as $column) {
+			try {
+				if ($column->isVirtual()) {
+					[$settings, $targetColumn] = $this->resolveLookupTarget($column, $columnsMap);
+				} else {
+					$settings = $column->getCustomSettingsObject(RelationSettings::class);
+					$targetColumn = $columnsMap[$settings->labelColumn] ?? null;
+					if (!$targetColumn) {
+						continue;
+					}
+					$this->columnService->assertRelationTargetColumn($settings, $targetColumn);
+				}
+				$targetKey = $settings->relationType . '_' . $settings->targetId;
+				$targets[$targetKey]['settings'] = $settings;
+				$targets[$targetKey]['columnIds'][$targetColumn->getId()] = true;
+			} catch (\InvalidArgumentException|DoesNotExistException $e) {
+				$this->logger->warning('Invalid relation settings for column ' . $column->getId(), ['exception' => $e]);
 			}
+		}
 
-			$target = sprintf('%s_%s_%s', $settings['relationType'], $settings['targetId'], $settings['labelColumn']);
-			$groups[$target] ??= [];
-			$groups[$target][] = $column;
+		foreach ($targets as $target) {
+			$settings = $target['settings'];
+			$cacheKeys = [];
+			foreach (array_keys($target['columnIds']) as $columnId) {
+				$key = $this->buildRelationCacheKey($settings->relationType, $settings->targetId, $columnId);
+				if (!isset($this->cacheRawRelationData[$key])) {
+					$cacheKeys[$columnId] = $key;
+				}
+			}
+			if (!$cacheKeys) {
+				continue;
+			}
+			try {
+				$rows = $this->fetchRowsForTarget($settings, array_keys($cacheKeys));
+			} catch (DoesNotExistException) {
+				$rows = [];
+			}
+			foreach ($cacheKeys as $key) {
+				$this->cacheRawRelationData[$key] = [];
+			}
+			foreach ($rows as $row) {
+				$rowId = (int)$row->getId();
+				$values = array_column($row->getData(), 'value', 'columnId');
+				foreach ($cacheKeys as $columnId => $key) {
+					$this->cacheRawRelationData[$key][$rowId] = ['id' => $rowId, 'value' => $values[$columnId] ?? null];
+				}
+			}
 		}
+	}
 
-		return $groups;
+	/**
+	 * @param array<int, Column> $columnsMap
+	 * @return array{RelationSettings, Column}
+	 */
+	private function resolveLookupTarget(Column $column, array $columnsMap): array {
+		$settings = $column->getCustomSettingsObject(LookupSettings::class);
+		$relation = $columnsMap[$settings->relationColumnId] ?? null;
+		$target = $columnsMap[$settings->targetColumnId] ?? null;
+		if (!$relation || $relation->getType() !== Column::TYPE_RELATION || $relation->getTableId() !== $column->getTableId()) {
+			throw new \InvalidArgumentException('Lookup relation must belong to the same table.');
+		}
+		if (!$target || in_array($target->getType(), [Column::TYPE_RELATION, Column::TYPE_LOOKUP], true)) {
+			throw new \InvalidArgumentException('Lookup target is missing or unsupported.');
+		}
+		$relationSettings = $relation->getCustomSettingsObject(RelationSettings::class);
+		$this->columnService->assertRelationTargetColumn($relationSettings, $target);
+		return [$relationSettings, $target];
 	}
 
 	/**
-	 * Get relation data for a specific column
+	 * Fetch relation labels for a specific target
 	 *
 	 * @param Column $column
-	 * @return array<int, array{id: int, label: string}> Indexed per row id
+	 * @return array<int, array{id: int, value: string}> Indexed per row id
+	 * @throws InternalError
 	 */
-	public function getRelationData(Column $column): array {
-		if ($column->getType() !== Column::TYPE_RELATION) {
-			return [];
+	private function fetchRelationLabelsForTarget(Column $column): array {
+		$settings = $column->getCustomSettingsObject(RelationSettings::class);
+
+		$cacheKey = $this->buildRelationCacheKey($settings->relationType, $settings->targetId, $settings->labelColumn);
+		if (isset($this->cacheRelationLabels[$cacheKey])) {
+			return $this->cacheRelationLabels[$cacheKey];
 		}
 
-		$settings = $column->getCustomSettingsArray();
-		if (empty($settings['relationType']) || empty($settings['targetId']) || empty($settings['labelColumn'])) {
+		try {
+			$targetColumn = $this->columnMapper->find($settings->labelColumn);
+			$this->columnService->assertRelationTargetColumn($settings, $targetColumn);
+			$rows = $this->fetchRawRelationValues($settings, $settings->labelColumn);
+		} catch (DoesNotExistException) {
+			$this->cacheRelationLabels[$cacheKey] = [];
 			return [];
 		}
 
-		$target = sprintf('%s_%s_%s', $settings['relationType'], $settings['targetId'], $settings['labelColumn']);
+		$result = $this->buildRelationLabels($rows, $targetColumn);
+		$this->cacheRelationLabels[$cacheKey] = $result;
+
+		return $result;
+	}
 
-		return $this->getRelationDataForTarget($target, $column);
+	/**
+	 * Build a cache key for relation data
+	 */
+	private function buildRelationCacheKey(string $relationType, int $targetId, int $labelColumn): string {
+		return sprintf('%s_%d_%d_%s', $relationType, $targetId, $labelColumn, $this->getCurrentUserId());
 	}
 
 	/**
-	 * Get relation data for a specific target
+	 * Collect all column IDs needed for relation and lookup processing
 	 *
-	 * @param string $target
-	 * @param Column $column
-	 * @return array<int, array{id: int, label: string}> Indexed per row id
-	 * @throws InternalError
+	 * @param Column[] $columns
+	 * @return int[]
 	 */
-	private function getRelationDataForTarget(string $target, Column $column): array {
-		// Check cache first
-		$cacheKey = $target . '_' . ($this->userId ?? 'anonymous');
-		if (isset($this->cacheRelationData[$cacheKey])) {
-			return $this->cacheRelationData[$cacheKey];
+	private function collectRelationColumnIds(array $columns): array {
+		$columnIds = [];
+
+		foreach ($columns as $column) {
+			try {
+				if ($column->getType() === Column::TYPE_LOOKUP) {
+					$settings = $column->getCustomSettingsObject(LookupSettings::class);
+					$columnIds[] = $settings->targetColumnId;
+					$columnIds[] = $settings->relationColumnId;
+				} elseif ($column->getType() === Column::TYPE_RELATION) {
+					$columnIds[] = $column->getCustomSettingsObject(RelationSettings::class)->labelColumn;
+				}
+			} catch (\InvalidArgumentException $e) {
+				$this->logger->warning('Invalid relation settings for column ' . $column->getId(), ['exception' => $e]);
+			}
 		}
 
-		$settings = $column->getCustomSettingsArray();
-		if (empty($settings[Column::RELATION_TYPE]) || empty($settings[Column::RELATION_TARGET_ID]) || empty($settings[Column::RELATION_LABEL_COLUMN])) {
-			$this->cacheRelationData[$cacheKey] = [];
+		return array_values(array_unique($columnIds));
+	}
+
+	/**
+	 * Fetch multiple columns by their IDs in a single batch
+	 *
+	 * @param int[] $columnIds
+	 * @return array<int, Column>
+	 */
+	private function fetchColumnsByIds(array $columnIds): array {
+		if (empty($columnIds)) {
 			return [];
 		}
 
-		$isView = $settings[Column::RELATION_TYPE] === 'view';
-		$targetId = $settings[Column::RELATION_TARGET_ID] ?? null;
-
 		try {
-			$targetColumn = $this->columnMapper->find($settings[Column::RELATION_LABEL_COLUMN]);
-			if ($isView) {
-				$view = $this->viewMapper->find($targetId);
-				$rows = $this->row2Mapper->findAll(
-					[$targetColumn->getId()],
-					$view->getTableId(),
-					null,
-					null,
-					$view->getFilterArray(),
-					$view->getSortArray(),
-					$this->userId
-				);
-			} else {
-				$rows = $this->row2Mapper->findAll(
-					[$targetColumn->getId()],
-					$targetId,
-					null,
-					null,
-					null,
-					null,
-					$this->userId
-				);
+			$columns = $this->columnMapper->findAll($columnIds);
+			$result = [];
+			foreach ($columns as $column) {
+				$result[$column->getId()] = $column;
 			}
-		} catch (DoesNotExistException) {
-			$this->cacheRelationData[$cacheKey] = [];
+			return $result;
+		} catch (\Exception $e) {
+			$this->logger->warning('Failed to fetch columns: ' . $e->getMessage());
 			return [];
 		}
+	}
+
+	/**
+	 * Fetch raw values for a relation target column
+	 *
+	 * @param RelationSettings $settings
+	 * @param int $targetColumnId
+	 * @return array<int, array{id: int, value: TablesRelationValue}>
+	 */
+	private function fetchRawRelationValues(RelationSettings $settings, int $targetColumnId): array {
+		$cacheKey = $this->buildRelationCacheKey($settings->relationType, $settings->targetId, $targetColumnId);
+		if (isset($this->cacheRawRelationData[$cacheKey])) {
+			return $this->cacheRawRelationData[$cacheKey];
+		}
+
+		try {
+			// Fetch only the requested column; labels do not determine whether a row is referenced
+			$rows = $this->fetchRowsForTarget($settings, [$targetColumnId]);
+			$lookupData = $this->buildRawRelationValues($rows, $targetColumnId);
+
+			$this->cacheRawRelationData[$cacheKey] = $lookupData;
+			return $lookupData;
+		} catch (DoesNotExistException $e) {
+			$this->logger->warning('Failed to fetch lookup data: ' . $e->getMessage());
+			$this->cacheRawRelationData[$cacheKey] = [];
+			return [];
+		}
+	}
+
+	/**
+	 * Fetch rows for a relation target
+	 *
+	 * @param RelationSettings $settings
+	 * @param int[] $columnIds
+	 * @return Row2[]
+	 * @throws DoesNotExistException
+	 */
+	private function fetchRowsForTarget(RelationSettings $settings, array $columnIds): array {
+		if ($settings->isView()) {
+			$view = $this->viewMapper->find($settings->targetId);
+			return $this->row2Mapper->findAll(
+				$columnIds,
+				$view->getTableId(),
+				filter: $view->getFilterArray(),
+				sort: $view->getSortArray(),
+				userId: $this->getCurrentUserId()
+			);
+		}
+
+		return $this->row2Mapper->findAll(
+			$columnIds,
+			$settings->targetId,
+			userId: $this->getCurrentUserId()
+		);
+	}
 
+	/**
+	 * Build relation labels from raw values
+	 *
+	 * @param array<int, array{id: int, value: TablesRelationValue}> $rows
+	 * @param Column $column
+	 * @return array<int, array{id: int, value: string}>
+	 */
+	private function buildRelationLabels(array $rows, Column $column): array {
+		$result = [];
+
+		foreach ($rows as $rowId => $row) {
+			$result[$rowId] = [
+				'id' => $rowId,
+				'value' => $this->formatRelationLabel($column, $row['value']),
+			];
+		}
+
+		return $result;
+	}
+
+	/**
+	 * Build lookup values from rows containing the target column
+	 *
+	 * @param Row2[] $rows
+	 * @param int $targetColumnId
+	 * @return array<int, array{id: int, value: TablesRelationValue}>
+	 */
+	private function buildRawRelationValues(array $rows, int $targetColumnId): array {
 		$result = [];
+
 		foreach ($rows as $row) {
 			$data = $row->getData();
-			$displayFieldData = array_filter($data, fn ($item) => $item['columnId'] === (int)$settings[Column::RELATION_LABEL_COLUMN]);
-			$value = reset($displayFieldData)['value'] ?? null;
-
-			// Structure compatible with Row2 format: {id: int, label: string}
 			$rowId = (int)$row->getId();
+
+			// Index the row's values by column ID
+			$values = array_column($data, 'value', 'columnId');
+
+			// Find the target column value
+			$targetValue = $values[$targetColumnId] ?? null;
+
+			// A relation references the row ID independently of its label
 			$result[$rowId] = [
 				'id' => $rowId,
-				'label' => (string)$value,
+				'value' => $targetValue,
 			];
 		}
 
-		$this->cacheRelationData[$cacheKey] = $result;
 		return $result;
 	}
+
+	/**
+	 * Format a cell value for display as a relation label.
+	 * Relation labels only support text-line and number columns.
+	 */
+	private function formatRelationLabel(Column $column, mixed $value): string {
+		if ($value === null || $value === '' || $value === []) {
+			return '';
+		}
+
+		return match ($column->getType()) {
+			Column::TYPE_TEXT => trim(strip_tags((string)$value)),
+			Column::TYPE_NUMBER => $this->formatNumberLabel($column, $value),
+			default => (string)$value,
+		};
+	}
+
+	private function formatNumberLabel(Column $column, mixed $value): string {
+		if ($value === null || $value === '') {
+			return '';
+		}
+		if (!is_numeric($value)) {
+			return (string)$value;
+		}
+		$decimals = $column->getNumberDecimals() ?? 0;
+		$formatted = number_format((float)$value, $decimals, '.', '');
+		return $column->getNumberPrefix() . $formatted . $column->getNumberSuffix();
+	}
 }
diff --git a/lib/Service/RowService.php b/lib/Service/RowService.php
index 3e98e7d4a2..67353e1528 100644
--- a/lib/Service/RowService.php
+++ b/lib/Service/RowService.php
@@ -374,7 +374,7 @@ private function cleanupAndValidateData(RowDataInput $data, array $columns, ?int
 		$readOnlyColumns = $view ? $this->extractColumnsByProperty($view, 'isReadonly') : [];
 		$mandatoryColumns = [];
 		foreach ($columns as $column) {
-			if ($column->getMandatory()) {
+			if ($column->getMandatory() && !$column->isVirtual()) {
 				$mandatoryColumns[$column->getId()] = true;
 			}
 		}
@@ -393,6 +393,10 @@ private function cleanupAndValidateData(RowDataInput $data, array $columns, ?int
 
 			$column = $this->getColumnFromColumnsArray($columnId, $columns);
 
+			if ($column && $column->isVirtual()) {
+				continue;
+			}
+
 			if ($column) {
 				$this->validateColumnValueLimits($column, $entry['value']);
 				$columnBusiness = $this->columnsHelper->getColumnBusinessObject($column);
@@ -442,7 +446,7 @@ private function validateMandatoryColumns(array $mandatoryColumns, RowDataInput
 			}
 
 			$column = $this->getColumnFromColumnsArray($columnId, $columns);
-			if (!$column) {
+			if (!$column || $column->isVirtual()) {
 				continue;
 			}
 
@@ -923,6 +927,8 @@ private function filterRowResult(?View $view, Row2 $row): Row2 {
 		}
 
 		$columnIds = $view->getColumnIds();
+		$columnIds = $this->row2Mapper->getColumnIdsWithRelationColumns($this->columnMapper->findAll($columnIds));
+
 		$row->filterDataByColumns($columnIds);
 		$row->filterDataByAliasByColumns($columnIds);
 
diff --git a/lib/Service/TableService.php b/lib/Service/TableService.php
index adf59034df..aa5fc9ad1c 100644
--- a/lib/Service/TableService.php
+++ b/lib/Service/TableService.php
@@ -546,6 +546,7 @@ public function update(int $id, ?string $title, ?string $emoji, ?string $descrip
 			$table->setColumnOrder(\json_encode($columnSettings->jsonSerialize()));
 		}
 		if ($sort !== null) {
+			$this->columnService->validateSortRules($sort);
 			$table->setSort(\json_encode($sort->jsonSerialize()));
 		}
 		$table->setLastEditBy($userId);
@@ -784,6 +785,7 @@ public function updateTableStructure(int $tableId, array $columns, array $views,
 
 		// Update sort rules
 		$sortRuleSet = SortRuleSet::createFromInputArray($sort, $columnsMap);
+		$this->columnService->validateSortRules($sortRuleSet);
 		$table->setSort(\json_encode($sortRuleSet->jsonSerialize()));
 
 		try {
diff --git a/lib/Service/ViewService.php b/lib/Service/ViewService.php
index c50ae3aadd..0f78b0627c 100644
--- a/lib/Service/ViewService.php
+++ b/lib/Service/ViewService.php
@@ -268,14 +268,14 @@ public function update(int $id, ViewUpdateInput $data, ?string $userId = null, b
 			$cardSourcesRequested = false;
 			// Resolved at most once: the column check and the card source rules both need it,
 			// and it costs a query.
-			$managedColumnIds = null;
+			$managedColumns = null;
 			$columnSelectionChanged = false;
 			foreach ($data->updateDetail() as $parameter => $value) {
 				if ($parameter === ViewUpdatableParameters::COLUMN_SETTINGS
 					&& $value instanceof ColumnSettings
 				) {
-					$managedColumnIds ??= $this->findManagedColumnIds($view, $userId);
-					$this->assertInputColumnsAreValid($value, $managedColumnIds);
+					$managedColumns ??= $this->findManagedColumnIds($view, $userId);
+					$this->assertInputColumnsAreValid($value, $managedColumns['columnIds'], $managedColumns['lookupColumnIds']);
 					$columnSelectionChanged = true;
 				}
 
@@ -283,6 +283,10 @@ public function update(int $id, ViewUpdateInput $data, ?string $userId = null, b
 					$cardSourcesRequested = true;
 				}
 
+				if ($value instanceof SortRuleSet) {
+					\OCP\Server::get(ColumnService::class)->validateSortRules($value);
+				}
+
 				if ($parameter === ViewUpdatableParameters::TECHNICAL_NAME) {
 					$this->assertTechnicalNameValid($value);
 				}
@@ -298,8 +302,8 @@ public function update(int $id, ViewUpdateInput $data, ?string $userId = null, b
 			if ($cardSourcesRequested || $columnSelectionChanged) {
 				$candidateIds = $view->getColumnIds();
 				if (empty($candidateIds)) {
-					$managedColumnIds ??= $this->findManagedColumnIds($view, $userId);
-					$candidateIds = $managedColumnIds;
+					$managedColumns ??= $this->findManagedColumnIds($view, $userId);
+					$candidateIds = $managedColumns['columnIds'];
 				}
 
 				if ($cardSourcesRequested) {
@@ -338,23 +342,38 @@ public function update(int $id, ViewUpdateInput $data, ?string $userId = null, b
 	}
 
 	/**
-	 * The ids of the columns the view may use.
+	 * The ids of the columns the view may use, split into all columns and lookup columns.
 	 *
 	 * ColumnService depends on this service, so it is looked up rather than injected.
 	 *
-	 * @return list<int>
+	 * @return array{columnIds: list<int>, lookupColumnIds: list<int>}
 	 */
 	private function findManagedColumnIds(View $view, string $userId): array {
-		$columnService = \OCP\Server::get(ColumnService::class);
+		$availableColumns = \OCP\Server::get(ColumnService::class)->findAllByManagedView($view, $userId);
+		$columnIds = [];
+		$lookupColumnIds = [];
+		foreach ($availableColumns as $column) {
+			$columnIds[] = $column->getId();
+			if ($column->getType() === Column::TYPE_LOOKUP) {
+				$lookupColumnIds[] = $column->getId();
+			}
+		}
 
-		return array_map(static fn (Column $column) => $column->getId(), $columnService->findAllByManagedView($view, $userId));
+		return ['columnIds' => $columnIds, 'lookupColumnIds' => $lookupColumnIds];
 	}
 
 	/**
 	 * @param list<int> $availableColumnIds
+	 * @param list<int> $lookupColumnIds
 	 */
-	protected function assertInputColumnsAreValid(ColumnSettings $columnSettings, array $availableColumnIds): void {
+	protected function assertInputColumnsAreValid(ColumnSettings $columnSettings, array $availableColumnIds, array $lookupColumnIds): void {
 		foreach ($columnSettings->columnInformation() as $columnInfo) {
+			if ($columnInfo instanceof ViewColumnInformation
+				&& $columnInfo->isMandatory()
+				&& in_array($columnInfo->getId(), $lookupColumnIds, true)
+			) {
+				throw new InvalidArgumentException('Lookup columns cannot be mandatory.');
+			}
 			if (!in_array($columnInfo->getId(), $availableColumnIds, true)
 				&& !Column::isValidMetaTypeId($columnInfo->getId())
 			) {
@@ -780,6 +799,7 @@ public function importView(int $tableId, array $view, string $userId): View {
 		$item->setLastEditAt($view['lastEditAt']);
 		$item->setDescription($view['description']);
 		$item->setColumns(json_encode($view['columnSettings']));
+		\OCP\Server::get(ColumnService::class)->validateSortRules(SortRuleSet::createFromInputArray($view['sort']));
 		$item->setSort(json_encode($view['sort']));
 		$item->setFilter(json_encode($view['filter']));
 		// A scheme may carry a layout this version does not know, which is dropped rather
diff --git a/openapi.json b/openapi.json
index c140ed6423..f5ecc9ff75 100644
--- a/openapi.json
+++ b/openapi.json
@@ -252,9 +252,6 @@
                     "customSettings": {
                         "type": "object",
                         "nullable": true,
-                        "required": [
-                            "width"
-                        ],
                         "properties": {
                             "width": {
                                 "type": "integer",
@@ -266,6 +263,29 @@
                             "imagePreviewSize": {
                                 "type": "integer",
                                 "format": "int64"
+                            },
+                            "relationType": {
+                                "type": "string",
+                                "enum": [
+                                    "table",
+                                    "view"
+                                ]
+                            },
+                            "targetId": {
+                                "type": "integer",
+                                "format": "int64"
+                            },
+                            "labelColumn": {
+                                "type": "integer",
+                                "format": "int64"
+                            },
+                            "relationColumnId": {
+                                "type": "integer",
+                                "format": "int64"
+                            },
+                            "targetColumnId": {
+                                "type": "integer",
+                                "format": "int64"
                             }
                         }
                     }
@@ -610,9 +630,6 @@
                     "customSettings": {
                         "type": "object",
                         "nullable": true,
-                        "required": [
-                            "width"
-                        ],
                         "properties": {
                             "width": {
                                 "type": "integer",
@@ -624,6 +641,29 @@
                             "imagePreviewSize": {
                                 "type": "integer",
                                 "format": "int64"
+                            },
+                            "relationType": {
+                                "type": "string",
+                                "enum": [
+                                    "table",
+                                    "view"
+                                ]
+                            },
+                            "targetId": {
+                                "type": "integer",
+                                "format": "int64"
+                            },
+                            "labelColumn": {
+                                "type": "integer",
+                                "format": "int64"
+                            },
+                            "relationColumnId": {
+                                "type": "integer",
+                                "format": "int64"
+                            },
+                            "targetColumnId": {
+                                "type": "integer",
+                                "format": "int64"
                             }
                         }
                     }
@@ -687,6 +727,117 @@
                     }
                 }
             },
+            "RelationData": {
+                "oneOf": [
+                    {
+                        "type": "object",
+                        "additionalProperties": {
+                            "type": "object",
+                            "required": [
+                                "column",
+                                "values"
+                            ],
+                            "properties": {
+                                "column": {
+                                    "nullable": true,
+                                    "allOf": [
+                                        {
+                                            "$ref": "#/components/schemas/Column"
+                                        }
+                                    ]
+                                },
+                                "values": {
+                                    "oneOf": [
+                                        {
+                                            "type": "object",
+                                            "additionalProperties": {
+                                                "type": "object",
+                                                "required": [
+                                                    "id",
+                                                    "value"
+                                                ],
+                                                "properties": {
+                                                    "id": {
+                                                        "type": "integer",
+                                                        "format": "int64"
+                                                    },
+                                                    "value": {
+                                                        "$ref": "#/components/schemas/RelationValue"
+                                                    }
+                                                }
+                                            }
+                                        },
+                                        {
+                                            "type": "array",
+                                            "maxItems": 0
+                                        }
+                                    ]
+                                }
+                            }
+                        }
+                    },
+                    {
+                        "type": "array",
+                        "maxItems": 0
+                    }
+                ]
+            },
+            "RelationValue": {
+                "nullable": true,
+                "anyOf": [
+                    {
+                        "type": "string"
+                    },
+                    {
+                        "type": "integer",
+                        "format": "int64"
+                    },
+                    {
+                        "type": "number",
+                        "format": "double"
+                    },
+                    {
+                        "type": "boolean"
+                    },
+                    {
+                        "type": "array",
+                        "items": {
+                            "oneOf": [
+                                {
+                                    "type": "integer",
+                                    "format": "int64"
+                                },
+                                {
+                                    "type": "string"
+                                }
+                            ]
+                        }
+                    },
+                    {
+                        "type": "array",
+                        "items": {
+                            "type": "object",
+                            "required": [
+                                "id",
+                                "type",
+                                "displayName"
+                            ],
+                            "properties": {
+                                "id": {
+                                    "type": "string"
+                                },
+                                "type": {
+                                    "type": "integer",
+                                    "format": "int64"
+                                },
+                                "displayName": {
+                                    "type": "string"
+                                }
+                            }
+                        }
+                    }
+                ]
+            },
             "Row": {
                 "type": "object",
                 "required": [
@@ -3994,7 +4145,8 @@
                                             "datetime",
                                             "select",
                                             "usergroup",
-                                            "relation"
+                                            "relation",
+                                            "lookup"
                                         ],
                                         "description": "Column main type"
                                     },
@@ -4428,7 +4580,8 @@
                                             "datetime",
                                             "select",
                                             "usergroup",
-                                            "relation"
+                                            "relation",
+                                            "lookup"
                                         ],
                                         "description": "Column main type"
                                     },
@@ -4832,7 +4985,8 @@
                                     },
                                     "customSettings": {
                                         "type": "object",
-                                        "default": {},
+                                        "nullable": true,
+                                        "default": null,
                                         "description": "Custom settings for the column",
                                         "additionalProperties": {
                                             "type": "object"
@@ -5141,6 +5295,228 @@
                 }
             }
         },
+        "/index.php/apps/tables/api/1/tables/{tableId}/relations": {
+            "get": {
+                "operationId": "api1-index-table-relations",
+                "summary": "Get all relation data for a table",
+                "description": "This endpoint allows CORS requests",
+                "tags": [
+                    "api1"
+                ],
+                "security": [
+                    {
+                        "basic_auth": []
+                    }
+                ],
+                "parameters": [
+                    {
+                        "name": "tableId",
+                        "in": "path",
+                        "description": "Table ID",
+                        "required": true,
+                        "schema": {
+                            "type": "integer",
+                            "format": "int64"
+                        }
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "Relation data returned",
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "$ref": "#/components/schemas/RelationData"
+                                }
+                            }
+                        }
+                    },
+                    "403": {
+                        "description": "No permissions",
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "type": "object",
+                                    "required": [
+                                        "message"
+                                    ],
+                                    "properties": {
+                                        "message": {
+                                            "type": "string"
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    },
+                    "500": {
+                        "description": "",
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "type": "object",
+                                    "required": [
+                                        "message"
+                                    ],
+                                    "properties": {
+                                        "message": {
+                                            "type": "string"
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    },
+                    "404": {
+                        "description": "Not found",
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "type": "object",
+                                    "required": [
+                                        "message"
+                                    ],
+                                    "properties": {
+                                        "message": {
+                                            "type": "string"
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    },
+                    "401": {
+                        "description": "Current user is not logged in",
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "type": "object",
+                                    "required": [
+                                        "message"
+                                    ],
+                                    "properties": {
+                                        "message": {
+                                            "type": "string"
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        "/index.php/apps/tables/api/1/views/{viewId}/relations": {
+            "get": {
+                "operationId": "api1-index-view-relations",
+                "summary": "Get all relation data for a view",
+                "description": "This endpoint allows CORS requests",
+                "tags": [
+                    "api1"
+                ],
+                "security": [
+                    {
+                        "basic_auth": []
+                    }
+                ],
+                "parameters": [
+                    {
+                        "name": "viewId",
+                        "in": "path",
+                        "description": "View ID",
+                        "required": true,
+                        "schema": {
+                            "type": "integer",
+                            "format": "int64"
+                        }
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "Relation data returned",
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "$ref": "#/components/schemas/RelationData"
+                                }
+                            }
+                        }
+                    },
+                    "403": {
+                        "description": "No permissions",
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "type": "object",
+                                    "required": [
+                                        "message"
+                                    ],
+                                    "properties": {
+                                        "message": {
+                                            "type": "string"
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    },
+                    "500": {
+                        "description": "",
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "type": "object",
+                                    "required": [
+                                        "message"
+                                    ],
+                                    "properties": {
+                                        "message": {
+                                            "type": "string"
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    },
+                    "404": {
+                        "description": "Not found",
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "type": "object",
+                                    "required": [
+                                        "message"
+                                    ],
+                                    "properties": {
+                                        "message": {
+                                            "type": "string"
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    },
+                    "401": {
+                        "description": "Current user is not logged in",
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "type": "object",
+                                    "required": [
+                                        "message"
+                                    ],
+                                    "properties": {
+                                        "message": {
+                                            "type": "string"
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        },
         "/index.php/apps/tables/api/1/tables/{tableId}/rows/simple": {
             "get": {
                 "operationId": "api1-index-table-rows-simple",
diff --git a/playwright/e2e/column-lookup.spec.ts b/playwright/e2e/column-lookup.spec.ts
new file mode 100644
index 0000000000..ed7d906dd6
--- /dev/null
+++ b/playwright/e2e/column-lookup.spec.ts
@@ -0,0 +1,105 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { test, expect } from '../support/fixtures'
+import {
+	createTable,
+	createTextLineColumn,
+	loadTable,
+	openCreateColumnModal,
+	openCreateRowModal,
+	fillInValueTextLine,
+	selectFromVueDropdown,
+} from '../support/commands'
+
+const sourceTableTitle = 'Test lookup source'
+const targetTableTitle = 'Test lookup target'
+const nameColumnTitle = 'Name'
+const cityColumnTitle = 'City'
+const relationColumnTitle = 'Refers to'
+const lookupColumnTitle = 'City of person'
+
+test.describe('Test column lookup', () => {
+	test.setTimeout(60000)
+
+	test('Create lookup column, row, and verify looked-up value in table', async ({ userPage: { page } }) => {
+		await page.goto('/index.php/apps/tables')
+
+		// source table with a name and a city column
+		await createTable(page, sourceTableTitle)
+		await loadTable(page, sourceTableTitle)
+		await createTextLineColumn(page, nameColumnTitle, '', '', true)
+		await createTextLineColumn(page, cityColumnTitle, '', '', false)
+
+		await openCreateRowModal(page)
+		await fillInValueTextLine(page, nameColumnTitle, 'Alice')
+		await fillInValueTextLine(page, cityColumnTitle, 'Berlin')
+		await page.locator('[data-cy="createRowSaveButton"]').click()
+		await expect(page.locator('[data-cy="ncTable"] [data-cy="customTableRow"]').filter({ hasText: 'Berlin' })).toBeVisible()
+
+		// target table with relation column to source
+		await createTable(page, targetTableTitle)
+		await loadTable(page, targetTableTitle)
+
+		await openCreateColumnModal(page, true)
+		await page.locator('[data-cy="columnTypeFormInput"]').clear()
+		await page.locator('[data-cy="columnTypeFormInput"]').fill(relationColumnTitle)
+		await page.locator('.columnTypeSelection .vs__open-indicator').click()
+		await page.locator('.vs__dropdown-menu .multiSelectOptionLabel').getByText('Relation', { exact: true }).click()
+
+		const targetColumnsResponse = page.waitForResponse(
+			r => r.url().includes('/apps/tables/api/1/tables/')
+				&& r.url().includes('/columns')
+				&& r.request().method() === 'GET',
+		)
+		await selectFromVueDropdown(page, 'Select target', sourceTableTitle)
+		await targetColumnsResponse
+		await selectFromVueDropdown(page, 'Select label for relation selection', nameColumnTitle)
+		await page.locator('[data-cy="createColumnSaveBtn"]').click()
+		await expect(
+			page.locator('[data-cy="ncTable"] table tr th').filter({ hasText: relationColumnTitle }),
+		).toBeVisible()
+
+		// lookup column reading 'City' through the relation column
+		await openCreateColumnModal(page, false)
+		await page.locator('[data-cy="columnTypeFormInput"]').clear()
+		await page.locator('[data-cy="columnTypeFormInput"]').fill(lookupColumnTitle)
+		await page.locator('.columnTypeSelection .vs__open-indicator').click()
+		await page.locator('.vs__dropdown-menu .multiSelectOptionLabel').getByText('Lookup', { exact: true }).click()
+
+		const lookupTargetColumnsResponse = page.waitForResponse(
+			r => r.url().includes('/apps/tables/api/1/tables/')
+				&& r.url().includes('/columns')
+				&& r.request().method() === 'GET',
+		)
+		await selectFromVueDropdown(page, 'Select relation column', relationColumnTitle)
+		await lookupTargetColumnsResponse
+		await selectFromVueDropdown(page, 'Select target column', cityColumnTitle)
+
+		await page.locator('[data-cy="createColumnSaveBtn"]').click()
+		await expect(
+			page.locator('[data-cy="ncTable"] table tr th').filter({ hasText: lookupColumnTitle }),
+		).toBeVisible()
+
+		// create a row and pick the source row as relation
+		const relationOptionsResponse = page.waitForResponse(
+			r => r.url().includes('/apps/tables/api/1/')
+				&& r.url().includes('/relations')
+				&& r.request().method() === 'GET',
+		)
+		await openCreateRowModal(page)
+		await relationOptionsResponse
+		await selectFromVueDropdown(page, 'Select relation value', 'Alice')
+
+		// the lookup field previews the looked-up value inside the modal
+		await expect(page.locator('[data-cy="createRowModal"]')).toContainText('Berlin')
+
+		await page.locator('[data-cy="createRowSaveButton"]').click()
+
+		const row = page.locator('[data-cy="ncTable"] [data-cy="customTableRow"]').filter({ hasText: 'Alice' })
+		await expect(row).toBeVisible()
+		await expect(row).toContainText('Berlin')
+	})
+})
diff --git a/playwright/e2e/column-relation.spec.ts b/playwright/e2e/column-relation.spec.ts
index ab0e6f32d6..577ad68445 100644
--- a/playwright/e2e/column-relation.spec.ts
+++ b/playwright/e2e/column-relation.spec.ts
@@ -3,7 +3,6 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 
-import { type Page } from '@playwright/test'
 import { test, expect } from '../support/fixtures'
 import {
 	createContext,
@@ -15,6 +14,7 @@ import {
 	openCreateColumnModal,
 	openCreateRowModal,
 	fillInValueTextLine,
+	selectFromVueDropdown,
 } from '../support/commands'
 
 const sourceTableTitle = 'Test relation source'
@@ -22,24 +22,6 @@ const targetTableTitle = 'Test relation target'
 const sourceColumnTitle = 'Name'
 const relationColumnTitle = 'Refers to'
 
-async function selectFromVueDropdown(page: Page, label: string, value: string) {
-	const input = page.locator(`[aria-label="${label}"] input, [aria-label="${label}"]`).first()
-	await input.click()
-	await input.clear()
-	await input.fill(value)
-
-	// NcSelect options may not expose a clean accessible name, so try several selectors
-	const optionByRole = page.getByRole('option', { name: new RegExp(value, 'i') }).first()
-	if (await optionByRole.isVisible({ timeout: 3000 }).catch(() => false)) {
-		await optionByRole.click()
-		return
-	}
-
-	const optionByText = page.locator('ul.vs__dropdown-menu li').filter({ hasText: new RegExp(value, 'i') }).first()
-	await optionByText.waitFor({ state: 'visible', timeout: 5000 })
-	await optionByText.click()
-}
-
 test.describe('Test column relation', () => {
 	test.setTimeout(60000)
 
@@ -64,7 +46,7 @@ test.describe('Test column relation', () => {
 		await page.locator('[data-cy="columnTypeFormInput"]').clear()
 		await page.locator('[data-cy="columnTypeFormInput"]').fill(relationColumnTitle)
 		await page.locator('.columnTypeSelection .vs__open-indicator').click()
-		await page.locator('.vs__dropdown-menu .multiSelectOptionLabel').filter({ hasText: 'Relation' }).click()
+		await page.locator('.vs__dropdown-menu .multiSelectOptionLabel').getByText('Relation', { exact: true }).click()
 
 		// configure the relation to point at the source table and use 'Name' as label
 		const targetColumnsResponse = page.waitForResponse(
@@ -94,6 +76,10 @@ test.describe('Test column relation', () => {
 		await expect(
 			page.locator('[data-cy="ncTable"] [data-cy="customTableRow"]').filter({ hasText: 'Alice' }),
 		).toBeVisible()
+		await page.reload()
+		const row = page.locator('[data-cy="ncTable"] [data-cy="customTableRow"]').filter({ hasText: 'Alice' })
+		await row.locator('.cell-relation .non-edit-mode').click()
+		await expect(row.locator('.cell-relation .vs__selected')).toContainText('Alice')
 	})
 
 	test('Relation labels render inside an application context', async ({ userPage: { page } }) => {
@@ -120,7 +106,7 @@ test.describe('Test column relation', () => {
 		await page.locator('[data-cy="columnTypeFormInput"]').clear()
 		await page.locator('[data-cy="columnTypeFormInput"]').fill(relationColumnTitle)
 		await page.locator('.columnTypeSelection .vs__open-indicator').click()
-		await page.locator('.vs__dropdown-menu .multiSelectOptionLabel').filter({ hasText: 'Relation' }).click()
+		await page.locator('.vs__dropdown-menu .multiSelectOptionLabel').getByText('Relation', { exact: true }).click()
 
 		const targetColumnsResponse = page.waitForResponse(
 			r => r.url().includes('/apps/tables/api/1/tables/')
diff --git a/playwright/support/commands.ts b/playwright/support/commands.ts
index fe66200ba2..0f0e0883cc 100644
--- a/playwright/support/commands.ts
+++ b/playwright/support/commands.ts
@@ -1209,3 +1209,21 @@ export async function fillInValueSelectionCheck(
 		)
 		.click()
 }
+
+export async function selectFromVueDropdown(page: Page, label: string, value: string) {
+	const input = page.locator(`[aria-label="${label}"] input, [aria-label="${label}"]`).first()
+	await input.click()
+	await input.clear()
+	await input.fill(value)
+
+	// NcSelect options may not expose a clean accessible name, so try several selectors
+	const optionByRole = page.getByRole('option', { name: new RegExp(value, 'i') }).first()
+	if (await optionByRole.isVisible({ timeout: 3000 }).catch(() => false)) {
+		await optionByRole.click()
+		return
+	}
+
+	const optionByText = page.locator('ul.vs__dropdown-menu li').filter({ hasText: new RegExp(value, 'i') }).first()
+	await optionByText.waitFor({ state: 'visible', timeout: 5000 })
+	await optionByText.click()
+}
diff --git a/src/modules/main/partials/ColumnFormComponent.vue b/src/modules/main/partials/ColumnFormComponent.vue
index 491ae29b7c..5394b2c85c 100644
--- a/src/modules/main/partials/ColumnFormComponent.vue
+++ b/src/modules/main/partials/ColumnFormComponent.vue
@@ -23,6 +23,7 @@ import DatetimeTimeForm from '../../../shared/components/ncTable/partials/rowTyp
 import TextRichForm from '../../../shared/components/ncTable/partials/rowTypePartials/TextRichForm.vue'
 import UsergroupForm from '../../../shared/components/ncTable/partials/rowTypePartials/UsergroupForm.vue'
 import RelationForm from '../../../shared/components/ncTable/partials/rowTypePartials/RelationForm.vue'
+import LookupForm from '../../../shared/components/ncTable/partials/rowTypePartials/LookupForm.vue'
 
 export default {
 	name: 'ColumnFormComponent',
@@ -42,6 +43,7 @@ export default {
 		DatetimeTimeForm,
 		UsergroupForm,
 		RelationForm,
+		LookupForm,
 	},
 	props: {
 		column: {
diff --git a/src/modules/main/partials/ColumnTypeSelection.vue b/src/modules/main/partials/ColumnTypeSelection.vue
index 9f861c91ab..3f4531fe64 100644
--- a/src/modules/main/partials/ColumnTypeSelection.vue
+++ b/src/modules/main/partials/ColumnTypeSelection.vue
@@ -20,6 +20,7 @@
 				<DatetimeIcon v-if="props.id === 'datetime'" />
 				<ContactsIcon v-if="props.id === 'usergroup'" />
 				<RelationIcon v-if="props.id === 'relation'" />
+				<RelationIcon v-if="props.id === 'lookup'" />
 				<div class="multiSelectOptionLabel">
 					{{ props.label }}
 				</div>
@@ -35,6 +36,7 @@
 			<DatetimeIcon v-if="props.id === 'datetime'" />
 			<ContactsIcon v-if="props.id === 'usergroup'" />
 			<RelationIcon v-if="props.id === 'relation'" />
+			<RelationIcon v-if="props.id === 'lookup'" />
 			<div class="multiSelectOptionLabel">
 				{{ props.label }}
 			</div>
@@ -94,6 +96,7 @@ export default {
 				{ id: 'datetime', label: t('tables', 'Date and time') },
 				{ id: 'usergroup', label: t('tables', 'Users and groups') },
 				{ id: 'relation', label: t('tables', 'Relation') },
+				{ id: 'lookup', label: t('tables', 'Lookup') },
 			],
 		}
 	},
diff --git a/src/modules/main/partials/editTablePartials/DefaultSortRules.vue b/src/modules/main/partials/editTablePartials/DefaultSortRules.vue
index 2e21447fd3..b47b2cf55b 100644
--- a/src/modules/main/partials/editTablePartials/DefaultSortRules.vue
+++ b/src/modules/main/partials/editTablePartials/DefaultSortRules.vue
@@ -79,6 +79,7 @@ export default {
 				ColumnTypes.SelectionMulti,
 				ColumnTypes.TextLink,
 				ColumnTypes.Usergroup,
+				ColumnTypes.Lookup,
 			].includes(col.type)
 		},
 		eligibleColumns(selectedId) {
diff --git a/src/modules/main/partials/editViewPartials/SelectedViewColumns.vue b/src/modules/main/partials/editViewPartials/SelectedViewColumns.vue
index 9d4526eadd..3a77455609 100644
--- a/src/modules/main/partials/editViewPartials/SelectedViewColumns.vue
+++ b/src/modules/main/partials/editViewPartials/SelectedViewColumns.vue
@@ -38,8 +38,8 @@
 					<NcActionCheckbox
 						v-if="selectedColumns.includes(column.id)"
 						data-cy="columnReadonlyCheckbox"
-						:model-value="column.viewColumnInformation?.readonly"
-						:disabled="isMandatory(column)"
+						:model-value="column.isVirtual() || column.viewColumnInformation?.readonly"
+						:disabled="isMandatory(column) || column.isVirtual()"
 						@change="onReadonlyChanged(column.id, $event.target.checked)">
 						{{ t('tables', 'Read only') }}
 					</NcActionCheckbox>
@@ -48,7 +48,7 @@
 						v-if="selectedColumns.includes(column.id)"
 						data-cy="columnMandatoryCheckbox"
 						:model-value="isMandatory(column)"
-						:disabled="column.viewColumnInformation?.readonly"
+						:disabled="column.viewColumnInformation?.readonly || column.isVirtual()"
 						@change="onMandatoryChanged(column.id, $event.target.checked)">
 						{{ t('tables', 'Mandatory') }}
 					</NcActionCheckbox>
@@ -132,6 +132,12 @@ export default {
 		columns: {
 			handler(newColumns) {
 				this.mutableColumns = newColumns
+				for (const column of newColumns ?? []) {
+					if (column.isVirtual() && column.viewColumnInformation) {
+						column.viewColumnInformation.mandatory = false
+						column.viewColumnInformation.readonly = true
+					}
+				}
 			},
 			deep: true,
 			immediate: true,
diff --git a/src/modules/main/partials/editViewPartials/filter/FilterEntry.vue b/src/modules/main/partials/editViewPartials/filter/FilterEntry.vue
index 2abf07d181..d2a38c4a81 100644
--- a/src/modules/main/partials/editViewPartials/filter/FilterEntry.vue
+++ b/src/modules/main/partials/editViewPartials/filter/FilterEntry.vue
@@ -230,10 +230,10 @@ export default {
 				// Get relations from DataStore using the column's tableId
 				const dataStore = useDataStore()
 				const columnRelations = dataStore.getRelations(this.selectedColumn.id)
-				Object.values(columnRelations).forEach(item => {
+				Object.entries(columnRelations.values || {}).forEach(([, item]) => {
 					options.push({
 						id: '@relation-id-' + item.id,
-						label: item.label,
+						label: item.value,
 					})
 				})
 
diff --git a/src/modules/main/partials/editViewPartials/sort/SortForm.vue b/src/modules/main/partials/editViewPartials/sort/SortForm.vue
index 52cb907c32..a35356ab6f 100644
--- a/src/modules/main/partials/editViewPartials/sort/SortForm.vue
+++ b/src/modules/main/partials/editViewPartials/sort/SortForm.vue
@@ -135,6 +135,7 @@ export default {
 				ColumnTypes.SelectionMulti,
 				ColumnTypes.TextLink,
 				ColumnTypes.Usergroup,
+				ColumnTypes.Lookup,
 			].includes(col.type)
 		},
 		eligibleColumns(selectedId) { // filter sortable and unused columns
diff --git a/src/modules/modals/CreateColumn.vue b/src/modules/modals/CreateColumn.vue
index ae8c311e98..791d76d875 100644
--- a/src/modules/modals/CreateColumn.vue
+++ b/src/modules/modals/CreateColumn.vue
@@ -18,7 +18,8 @@
 						v-model:selected-views="column.selectedViews"
 						:title-missing-error="titleMissingError"
 						:technical-name-invalid-error="technicalNameInvalidError"
-						:width-invalid-error="widthInvalidError" />
+						:width-invalid-error="widthInvalidError"
+						:mandatory-disabled="column.isVirtual()" />
 				</div>
 				<div class="fix-col-2" style="display: block">
 					<div class="row no-padding-on-mobile space-L">
@@ -127,6 +128,7 @@ import TextRichForm from '../../shared/components/ncTable/partials/columnTypePar
 import { ColumnTypes } from '../../shared/components/ncTable/mixins/columnHandler.js'
 import UsergroupForm from '../../shared/components/ncTable/partials/columnTypePartials/forms/UsergroupForm.vue'
 import RelationForm from '../../shared/components/ncTable/partials/columnTypePartials/forms/RelationForm.vue'
+import LookupForm from '../../shared/components/ncTable/partials/columnTypePartials/forms/LookupForm.vue'
 import { useTablesStore } from '../../store/store.js'
 import { useDataStore } from '../../store/data.js'
 import { mapActions } from 'pinia'
@@ -159,6 +161,7 @@ export default {
 		SelectionMultiForm,
 		UsergroupForm,
 		RelationForm,
+		LookupForm,
 	},
 	props: {
 		showModal: {
@@ -216,6 +219,9 @@ export default {
 				usergroupSelectTeams: false,
 				showUserStatus: false,
 				customSettings: {},
+				isVirtual() {
+					return this.type === ColumnTypes.Lookup
+				},
 			},
 			textAppAvailable: !!window.OCA?.Text?.createEditor,
 			addNewAfterSave: false,
@@ -337,6 +343,10 @@ export default {
 				showInfo(t('tables', 'Please select a target.'))
 			} else if (this.column.type === ColumnTypes.Relation && !this.column.customSettings?.labelColumn) {
 				showInfo(t('tables', 'Please select a label for relation selection.'))
+			} else if (this.column.type === ColumnTypes.Lookup && !this.column.customSettings?.relationColumnId) {
+				showInfo(t('tables', 'Please select a relation column.'))
+			} else if (this.column.type === ColumnTypes.Lookup && !this.column.customSettings?.targetColumnId) {
+				showInfo(t('tables', 'Please select a target column.'))
 			} else {
 				this.column.title = title
 				this.$emit('save', this.prepareSubmitData())
@@ -417,6 +427,9 @@ export default {
 				data.customSettings.relationType = this.column.customSettings.relationType
 				data.customSettings.targetId = this.column.customSettings.targetId
 				data.customSettings.labelColumn = this.column.customSettings.labelColumn
+			} else if (this.column.isVirtual()) {
+				data.customSettings.relationColumnId = this.column.customSettings.relationColumnId
+				data.customSettings.targetColumnId = this.column.customSettings.targetColumnId
 			}
 			return data
 		},
@@ -473,6 +486,9 @@ export default {
 				usergroupSelectTeams: false,
 				showUserStatus: false,
 				customSettings: {},
+				isVirtual() {
+					return this.type === ColumnTypes.Lookup
+				},
 			}
 			if (mainForm) {
 				this.column.title = ''
diff --git a/src/modules/modals/CreateRow.vue b/src/modules/modals/CreateRow.vue
index 3d54a6e720..7fecb0e9e6 100644
--- a/src/modules/modals/CreateRow.vue
+++ b/src/modules/modals/CreateRow.vue
@@ -11,13 +11,13 @@
 		<div class="modal__content" @keydown="onKeydown">
 			<div v-for="column in nonMetaColumns" :key="column.id" :data-cy="column.title">
 				<ColumnFormComponent
-					v-model:value="row[column.id]"
+					v-model:value="row[column.getValueColumnId()]"
 					:column="column" />
-				<NcNoteCard v-if="isMandatory(column) && !isValueValidForColumn(row[column.id], column)"
+				<NcNoteCard v-if="isMandatory(column) && !isValueValidForColumn(row[column.getValueColumnId()], column)"
 					type="error">
 					{{ t('tables', '"{columnTitle}" should not be empty', { columnTitle: column.title }) }}
 				</NcNoteCard>
-				<NcNoteCard v-if="row[column.id] && column.type === 'text-link' && !isValidUrlProtocol(row[column.id])"
+				<NcNoteCard v-if="row[column.getValueColumnId()] && column.type === 'text-link' && !isValidUrlProtocol(row[column.getValueColumnId()])"
 					type="error">
 					{{ t('tables', 'Invalid protocol. Allowed: {allowed}', {allowed: allowedProtocols.join(', ')}) }}
 				</NcNoteCard>
@@ -104,7 +104,7 @@ export default {
 			return this.checkMandatoryFields(this.row)
 		},
 		hasInvalidUrlProtocol() {
-			return this.nonMetaColumns.some(col => col.type === 'text-link' && !this.isValidUrlProtocol(this.row[col.id]))
+			return this.nonMetaColumns.some(col => col.type === 'text-link' && !this.isValidUrlProtocol(this.row[col.getValueColumnId()]))
 		},
 		dialogTitle() {
 			return this.isFormMode ? t('tables', 'Fill form') : t('tables', 'Create row')
diff --git a/src/modules/modals/EditColumn.vue b/src/modules/modals/EditColumn.vue
index 6b6fcf007f..fcb175a39c 100644
--- a/src/modules/modals/EditColumn.vue
+++ b/src/modules/modals/EditColumn.vue
@@ -18,7 +18,8 @@
 						:edit-column="true"
 						:title-missing-error="editErrorTitle"
 						:technical-name-invalid-error="technicalNameInvalidError"
-						:width-invalid-error="widthInvalidError" />
+						:width-invalid-error="widthInvalidError"
+						:mandatory-disabled="column.isVirtual()" />
 				</div>
 				<div class="col-2 space-LR space-T">
 					<component :is="getColumnForm" v-model:can-save="canSave"
@@ -71,6 +72,7 @@ import DatetimeDateForm from '../../shared/components/ncTable/partials/columnTyp
 import DatetimeTimeForm from '../../shared/components/ncTable/partials/columnTypePartials/forms/DatetimeTimeForm.vue'
 import UsergroupForm from '../../shared/components/ncTable/partials/columnTypePartials/forms/UsergroupForm.vue'
 import RelationForm from '../../shared/components/ncTable/partials/columnTypePartials/forms/RelationForm.vue'
+import LookupForm from '../../shared/components/ncTable/partials/columnTypePartials/forms/LookupForm.vue'
 import { ColumnTypes } from '../../shared/components/ncTable/mixins/columnHandler.js'
 import moment from '@nextcloud/moment'
 import { mapActions } from 'pinia'
@@ -107,6 +109,7 @@ export default {
 		NcUserBubble,
 		UsergroupForm,
 		RelationForm,
+		LookupForm,
 	},
 	props: {
 		column: {
diff --git a/src/modules/modals/EditRow.vue b/src/modules/modals/EditRow.vue
index 22be6ab5eb..84e222beab 100644
--- a/src/modules/modals/EditRow.vue
+++ b/src/modules/modals/EditRow.vue
@@ -37,13 +37,13 @@
 			<div v-if="activeTabId === 'edit' && localRow" class="row">
 				<div v-for="column in nonMetaColumns" :key="column.id">
 					<ColumnFormComponent
-						v-model:value="localRow[column.id]"
+						v-model:value="localRow[column.getValueColumnId()]"
 						:column="column" />
-					<NcNoteCard v-if="isMandatory(column) && !isValueValidForColumn(localRow[column.id], column)"
+					<NcNoteCard v-if="isMandatory(column) && !isValueValidForColumn(localRow[column.getValueColumnId()], column)"
 						type="error">
 						{{ t('tables', '"{columnTitle}" should not be empty', { columnTitle: column.title }) }}
 					</NcNoteCard>
-					<NcNoteCard v-if="localRow[column.id] && column.type === 'text-link' && !isValidUrlProtocol(localRow[column.id])"
+					<NcNoteCard v-if="localRow[column.getValueColumnId()] && column.type === 'text-link' && !isValidUrlProtocol(localRow[column.getValueColumnId()])"
 						type="error">
 						{{ t('tables', 'Invalid protocol. Allowed: {allowed}', {allowed: allowedProtocols.join(', ')}) }}
 					</NcNoteCard>
@@ -162,7 +162,7 @@ export default {
 			return this.checkMandatoryFields(this.localRow)
 		},
 		hasInvalidUrlProtocol() {
-			return this.nonMetaColumns.some(col => col.type === 'text-link' && !this.isValidUrlProtocol(this.localRow[col.id]))
+			return this.nonMetaColumns.some(col => col.type === 'text-link' && !this.isValidUrlProtocol(this.localRow[col.getValueColumnId()]))
 		},
 	},
 	watch: {
@@ -198,12 +198,12 @@ export default {
 
 				// Ensure all columns have entries, even if missing from row data
 				this.columns.forEach(column => {
-					if (!(column.id in tmp)) {
+					if (!(column.getValueColumnId() in tmp)) {
 						// For usergroup columns, initialize as empty array
 						if (column.type === 'usergroup') {
-							tmp[column.id] = []
+							tmp[column.getValueColumnId()] = []
 						} else {
-							tmp[column.id] = null
+							tmp[column.getValueColumnId()] = null
 						}
 					}
 				})
diff --git a/src/modules/modals/ImportPreview.vue b/src/modules/modals/ImportPreview.vue
index d796032a87..e959f5e33e 100644
--- a/src/modules/modals/ImportPreview.vue
+++ b/src/modules/modals/ImportPreview.vue
@@ -120,7 +120,8 @@ export default {
 				return []
 			}
 
-			const columns = this.existingColumns.map(column => ({
+			const filteredColumns = this.existingColumns.filter(column => !column.isVirtual())
+			const columns = filteredColumns.map(column => ({
 				id: column.id,
 				label: column.title,
 			}))
diff --git a/src/shared/components/ncTable/NcTable.vue b/src/shared/components/ncTable/NcTable.vue
index db05bdd3b0..76634a656a 100644
--- a/src/shared/components/ncTable/NcTable.vue
+++ b/src/shared/components/ncTable/NcTable.vue
@@ -294,11 +294,11 @@ export default {
 			// if we don't have to search and/or filter
 			if (!this.viewSetting?.filter?.length > 0 && !this.viewSetting?.searchString) {
 				// cleanup markers
-				if (this.rows && this.columns) {
+				if (this.rows && this.parsedColumns) {
 					this.rows.forEach(row => {
 						if (row && row.data) {
-							this.columns.forEach(column => {
-								const cell = row.data.find(item => item && item.columnId === column.id)
+							this.parsedColumns.forEach(column => {
+								const cell = row.data.find(item => item && item.columnId === (column.id < 0 ? column.id : column.getValueColumnId()))
 								if (cell === undefined) {
 									return
 								}
@@ -314,7 +314,7 @@ export default {
 			const data = [] // array of rows
 			const searchString = this.viewSetting?.searchString
 			// each row
-			if (!this.rows || !this.columns) {
+			if (!this.rows || !this.parsedColumns) {
 				return []
 			}
 
@@ -326,7 +326,7 @@ export default {
 				let searchStatusRow = false
 
 				// each column in a row => cell
-				this.columns.forEach(column => {
+				this.parsedColumns.forEach(column => {
 					let filterStatus = null
 					let searchStatus = true
 					const filters = getFiltersForColumn(column, this.viewSetting)
@@ -351,7 +351,7 @@ export default {
 							break
 						}
 					} else {
-						cell = row.data.find(item => item && item.columnId === column.id)
+						cell = row.data.find(item => item && item.columnId === column.getValueColumnId())
 					}
 
 					if (cell === undefined) {
@@ -390,7 +390,7 @@ export default {
 			return data
 		},
 		getSearchedAndFilteredAndSortedRows() {
-			const allColumns = this.columns.concat(MetaColumns)
+			const allColumns = this.parsedColumns.concat(MetaColumns)
 			const sort = (sortCols) => {
 				const sortColumn = allColumns.find(item => item.id === sortCols?.[0].columnId)
 				const nextSorts = []
diff --git a/src/shared/components/ncTable/mixins/cellEditMixin.js b/src/shared/components/ncTable/mixins/cellEditMixin.js
index fdf7d26512..426d624097 100644
--- a/src/shared/components/ncTable/mixins/cellEditMixin.js
+++ b/src/shared/components/ncTable/mixins/cellEditMixin.js
@@ -57,7 +57,7 @@ export default {
 			}
 
 			// Prevent editing for readonly columns
-			if (this.isView && this.column?.viewColumnInformation?.readonly) {
+			if (this.column.isVirtual() || (this.isView && this.column?.viewColumnInformation?.readonly)) {
 				return false
 			}
 
diff --git a/src/shared/components/ncTable/mixins/columnClass.js b/src/shared/components/ncTable/mixins/columnClass.js
index 6dcf0fb368..c142158627 100644
--- a/src/shared/components/ncTable/mixins/columnClass.js
+++ b/src/shared/components/ncTable/mixins/columnClass.js
@@ -4,6 +4,7 @@
  */
 import { Filters } from './filter.js'
 import { MagicFields } from './magicFields.js'
+import { ColumnTypes } from './columnHandler.js'
 
 export class AbstractColumn {
 
@@ -31,6 +32,16 @@ export class AbstractColumn {
 		return typeof this.sort === 'function'
 	}
 
+	/**
+	 * Virtual columns do not store their own cell data,
+	 * their values are derived from a related column.
+	 *
+	 * @return {boolean}
+	 */
+	isVirtual() {
+		return this.type === ColumnTypes.Lookup
+	}
+
 	getNextSortsResult(nextSorts, rowA, rowB) {
 		if (!nextSorts) {
 			return 0
@@ -82,6 +93,16 @@ export class AbstractColumn {
 		return value
 	}
 
+	/**
+	 * Get the id of the column whose cell holds this column's value.
+	 * Virtual columns may source their value from another column.
+	 *
+	 * @return {number} The column id to read the cell value from
+	 */
+	getValueColumnId() {
+		return this.id
+	}
+
 }
 
 export class AbstractUsergroupColumn extends AbstractColumn {
diff --git a/src/shared/components/ncTable/mixins/columnHandler.js b/src/shared/components/ncTable/mixins/columnHandler.js
index 71664a93f7..c2e5ea0f01 100644
--- a/src/shared/components/ncTable/mixins/columnHandler.js
+++ b/src/shared/components/ncTable/mixins/columnHandler.js
@@ -18,6 +18,7 @@ export const ColumnTypes = {
 	Datetime: 'datetime',
 	Usergroup: 'usergroup',
 	Relation: 'relation',
+	Lookup: 'lookup',
 }
 
 export function getColumnWidthStyle(column) {
diff --git a/src/shared/components/ncTable/mixins/columnParser.js b/src/shared/components/ncTable/mixins/columnParser.js
index 4461e6e5ce..2e7c112d7d 100644
--- a/src/shared/components/ncTable/mixins/columnParser.js
+++ b/src/shared/components/ncTable/mixins/columnParser.js
@@ -18,6 +18,7 @@ import TextLongColumn from './columnsTypes/textLong.js'
 import TextRichColumn from './columnsTypes/textRich.js'
 import UsergroupColumn from './columnsTypes/usergroup.js'
 import RelationColumn from './columnsTypes/relation.js'
+import LookupColumn from './columnsTypes/lookup.js'
 
 export function parseCol(col) {
 	const columnType = col.type + (col.subtype === '' ? '' : '-' + col.subtype)
@@ -37,6 +38,7 @@ export function parseCol(col) {
 	case ColumnTypes.DatetimeTime: return new DatetimeTimeColumn(col)
 	case ColumnTypes.Usergroup: return new UsergroupColumn(col)
 	case ColumnTypes.Relation: return new RelationColumn(col)
+	case ColumnTypes.Lookup: return new LookupColumn(col)
 	default: throw Error(columnType + ' is not a valid column type!')
 	}
 }
diff --git a/src/shared/components/ncTable/mixins/columnsTypes/lookup.js b/src/shared/components/ncTable/mixins/columnsTypes/lookup.js
new file mode 100644
index 0000000000..b852a1a69c
--- /dev/null
+++ b/src/shared/components/ncTable/mixins/columnsTypes/lookup.js
@@ -0,0 +1,132 @@
+/**
+ * SPDX-FileCopyrightText: 2024 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { AbstractColumn } from '../columnClass.js'
+import { ColumnTypes } from '../columnHandler.js'
+import { useDataStore } from '../../../../../store/data.js'
+
+export default class LookupColumn extends AbstractColumn {
+
+	constructor(col) {
+		super(col)
+		this.type = ColumnTypes.Lookup
+		this.subtype = ''
+	}
+
+	/**
+	 * Format the value for display
+	 * @param {unknown} value The value to format
+	 * @return {string} The formatted value
+	 */
+	formatValue(value) {
+		if (value === null || value === undefined) {
+			return ''
+		}
+		// Return the virtual value as is - it comes from the related table
+		return String(value)
+	}
+
+	/**
+	 * Parse the value from input
+	 * @param {unknown} value The value to parse
+	 * @return {unknown} The parsed value
+	 */
+	parseValue(value) {
+		// This is a virtual column, no input parsing needed
+		// Values come from related rows via backend
+		return value
+	}
+
+	/**
+	 * The lookup value is sourced from the referenced relation column's cell.
+	 * @return {number} The relation column id to read the cell value from
+	 */
+	getValueColumnId() {
+		return this.customSettings?.relationColumnId
+	}
+
+	resolveValue(value) {
+		const rowId = value !== null && typeof value === 'object' ? value.value : value
+		const data = useDataStore().getRelations(this.id)
+		const column = data.column ?? null
+		const row = data.values?.[rowId] ?? null
+		let status = 'unavailable'
+		if (data.loading) status = 'loading'
+		else if (data.column === null) status = 'unavailable'
+		else if (rowId === null || rowId === undefined || rowId === '') status = 'empty'
+		else if (column && row) status = row.value === null || row.value === undefined ? 'empty' : 'ready'
+		return { column, row, status, value: status === 'ready' ? column.parseValue(row.value) : null }
+	}
+
+	getValueString(valueObject) {
+		valueObject = valueObject || this.value || null
+		// Resolve the lookup through its source relation cell
+		const lookup = this.resolveValue(valueObject?.value)
+		if (lookup.status === 'ready') {
+			return lookup.column.getValueString({ value: lookup.row.value }) ?? ''
+		}
+		// Unavailable lookup data must not be exported as a source row ID
+		return ''
+	}
+
+	default() {
+		// Virtual columns don't have default values
+		return null
+	}
+
+	/**
+	 * Check if filter matches the cell value
+	 * @param {unknown} cell The cell to check
+	 * @param {unknown} filter The filter to apply
+	 * @return {boolean} Whether the filter matches
+	 */
+	isFilterFound(cell, filter) {
+		return false
+	}
+
+	isSearchStringFound(cell, searchString) {
+		const lookup = this.resolveValue(cell?.value)
+		const found = lookup.status === 'ready'
+			&& lookup.column.isSearchStringFound({ value: lookup.row.value }, searchString)
+		if (found) cell.searchStringFound = true
+		return !!found
+	}
+
+	sort(mode, nextSorts) {
+		const factor = mode === 'DESC' ? -1 : 1
+		const values = new WeakMap()
+		let targetComparator
+		const lookupForRow = row => {
+			if (!values.has(row)) {
+				const lookup = this.resolveValue(row.data.find(item => item.columnId === this.getValueColumnId())?.value)
+				lookup.sortRow = { ...row, data: [{ columnId: lookup.column?.id, value: lookup.row?.value }] }
+				values.set(row, lookup)
+			}
+			return values.get(row)
+		}
+		return (rowA, rowB) => {
+			const lookupA = lookupForRow(rowA)
+			const lookupB = lookupForRow(rowB)
+			const valueA = lookupA.status === 'ready' ? lookupA.value : null
+			const valueB = lookupB.status === 'ready' ? lookupB.value : null
+			let result = 0
+			if (valueA === null || valueB === null) {
+				result = (valueA === null ? -1 : 1) * factor
+				if (valueA === valueB) result = 0
+			} else if (lookupA.column.type.startsWith('number')) {
+				result = (valueA - valueB) * factor
+			} else if (lookupA.column.canSort()) {
+				targetComparator ??= lookupA.column.sort(mode)
+				result = targetComparator(lookupA.sortRow, lookupB.sortRow)
+			} else {
+				// Compare display strings for target types without a comparator
+				const labelA = String(lookupA.column.getValueString({ value: lookupA.row.value }) ?? '').toLowerCase()
+				const labelB = String(lookupB.column.getValueString({ value: lookupB.row.value }) ?? '').toLowerCase()
+				result = labelA.localeCompare(labelB) * factor
+			}
+			return result || super.getNextSortsResult(nextSorts, rowA, rowB)
+		}
+	}
+
+}
diff --git a/src/shared/components/ncTable/mixins/columnsTypes/relation.js b/src/shared/components/ncTable/mixins/columnsTypes/relation.js
index 1464275892..2560fec04d 100644
--- a/src/shared/components/ncTable/mixins/columnsTypes/relation.js
+++ b/src/shared/components/ncTable/mixins/columnsTypes/relation.js
@@ -31,19 +31,19 @@ export default class RelationColumn extends AbstractColumn {
 	/**
 	 * Parse the value from input
 	 * @param {unknown} value The value to parse
-	 * @return {unknown} The parsed value
+	 * @return {number|null} The parsed value
 	 */
 	parseValue(value) {
 		if (value === null || value === undefined || value === '') {
 			return null
 		}
-		// For single relations, return the value as is
-		return value
+		// Normalize relation IDs to match numeric option IDs
+		return Number(value)
 	}
 
 	getValueString(valueObject) {
 		valueObject = valueObject || this.value || null
-		return this.getLabel(valueObject.value)
+		return this.getLabel(valueObject.value) ?? String(valueObject.value)
 	}
 
 	getLabel(rowId) {
@@ -52,9 +52,9 @@ export default class RelationColumn extends AbstractColumn {
 			const dataStore = useDataStore()
 
 			const columnRelations = dataStore.getRelations(this.id)
-			const option = columnRelations[rowId]
+			const option = columnRelations.values?.[rowId]
 
-			return option ? option.label : ''
+			return option ? option.value : ''
 		} catch (error) {
 			console.warn('Failed to get relation label:', error)
 			return ''
diff --git a/src/shared/components/ncTable/mixins/exportTableMixin.js b/src/shared/components/ncTable/mixins/exportTableMixin.js
index e82d56b04f..cc9efc8162 100644
--- a/src/shared/components/ncTable/mixins/exportTableMixin.js
+++ b/src/shared/components/ncTable/mixins/exportTableMixin.js
@@ -26,7 +26,7 @@ export default {
 				columns.forEach(column => {
 					// if a normal column
 					if (column.id >= 0) {
-						const set = row.data ? row.data.find(d => d.columnId === column.id) || '' : null
+						const set = row.data ? row.data.find(d => d.columnId === column.getValueColumnId()) || '' : null
 						rowData[column.title] = set ? column.getValueString(set) : ''
 					} else {
 						// if is a meta data column (id < 0)
diff --git a/src/shared/components/ncTable/mixins/rowHelper.js b/src/shared/components/ncTable/mixins/rowHelper.js
index 220feee220..1f4477a220 100644
--- a/src/shared/components/ncTable/mixins/rowHelper.js
+++ b/src/shared/components/ncTable/mixins/rowHelper.js
@@ -3,6 +3,7 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 import { ColumnTypes } from './columnHandler.js'
+import { isVirtualColumn } from '../../../utils/columnUtils.js'
 import { ALLOWED_PROTOCOLS } from '../../../constants.ts'
 import Moment from '@nextcloud/moment'
 
@@ -10,7 +11,7 @@ export default {
 	methods: {
 		isMandatory(column) {
 			const viewInfo = column?.viewColumnInformation ?? {}
-			return viewInfo.mandatory ?? column?.mandatory ?? false
+			return !isVirtualColumn(column) && (viewInfo.mandatory ?? column?.mandatory ?? false)
 		},
 		isValueValidForColumn(value, column) {
 			switch (column.type) {
@@ -100,7 +101,7 @@ export default {
 			if (!this.columns) return false
 			this.columns.forEach(col => {
 				if (this.isMandatory(col)) {
-					const validValue = this.isValueValidForColumn(row[col.id], col)
+					const validValue = this.isValueValidForColumn(row[col.getValueColumnId()], col)
 					mandatoryFieldsEmpty = mandatoryFieldsEmpty || !validValue
 				}
 			})
diff --git a/src/shared/components/ncTable/partials/TableCell.js b/src/shared/components/ncTable/partials/TableCell.js
index 2ab4e0729b..dab016f711 100644
--- a/src/shared/components/ncTable/partials/TableCell.js
+++ b/src/shared/components/ncTable/partials/TableCell.js
@@ -2,6 +2,7 @@
  * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
+import { defineAsyncComponent } from 'vue'
 import { ColumnTypes } from './../mixins/columnHandler.js'
 
 import TableCellHtml from './TableCellHtml.vue'
@@ -33,6 +34,9 @@ const COMPONENT_BY_COLUMN_TYPE = {
 	[ColumnTypes.DatetimeTime]: TableCellDateTime,
 	[ColumnTypes.Usergroup]: TableCellUsergroup,
 	[ColumnTypes.Relation]: TableCellRelation,
+	// Loaded asynchronously to break the circular dependency with
+	// TableCellLookup, which resolves cells via getTableCellComponent.
+	[ColumnTypes.Lookup]: defineAsyncComponent(() => import('./TableCellLookup.vue')),
 }
 
 export function getTableCellComponent(column) {
diff --git a/src/shared/components/ncTable/partials/TableCellLookup.vue b/src/shared/components/ncTable/partials/TableCellLookup.vue
new file mode 100644
index 0000000000..093c54d98a
--- /dev/null
+++ b/src/shared/components/ncTable/partials/TableCellLookup.vue
@@ -0,0 +1,61 @@
+<!--
+  - SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+  - SPDX-License-Identifier: AGPL-3.0-or-later
+-->
+<template>
+	<div>
+		<div v-if="lookup.status === 'loading'" class="icon-loading-small" :aria-label="t('tables', 'Loading lookup value')" />
+		<span v-else-if="lookup.status === 'unavailable'" :title="t('tables', 'The linked row or lookup column is no longer available.')">
+			{{ t('tables', 'Unavailable') }}
+		</span>
+		<component :is="getTableCellComponent(targetColumn)"
+			v-else-if="lookup.status === 'ready' && targetColumn"
+			:key="relatedRow?.id"
+			:column="targetColumn"
+			:row-id="rowId"
+			:value="targetValue"
+			:can-edit="false" />
+	</div>
+</template>
+
+<script>
+import { translate as t } from '@nextcloud/l10n'
+import { getTableCellComponent } from './TableCell.js'
+
+export default {
+	name: 'TableCellLookup',
+	props: {
+		column: {
+			type: Object,
+			required: true,
+		},
+		rowId: {
+			type: Number,
+			default: null,
+		},
+		value: {
+			type: [String, Number, Object],
+			default: null,
+		},
+	},
+	computed: {
+		lookup() {
+			return this.column.resolveValue(this.value)
+		},
+		targetColumn() {
+			return this.lookup.column
+		},
+		relatedRow() {
+			// Resolve the related row through the column's shared lookup resolver
+			return this.lookup.row
+		},
+		targetValue() {
+			return this.lookup.value
+		},
+	},
+	methods: {
+		t,
+		getTableCellComponent,
+	},
+}
+</script>
diff --git a/src/shared/components/ncTable/partials/TableCellRelation.vue b/src/shared/components/ncTable/partials/TableCellRelation.vue
index cd6b75ef7d..0ba6ef0fd9 100644
--- a/src/shared/components/ncTable/partials/TableCellRelation.vue
+++ b/src/shared/components/ncTable/partials/TableCellRelation.vue
@@ -38,8 +38,6 @@ import { translate as t } from '@nextcloud/l10n'
 import { NcSelect } from '@nextcloud/vue'
 import cellEditMixin from '../mixins/cellEditMixin.js'
 import { useDataStore } from '../../../../store/data.js'
-import { mapState } from 'pinia'
-import { useTablesStore } from '../../../../store/store.js'
 
 export default {
 	name: 'TableCellRelation',
@@ -74,10 +72,9 @@ export default {
 	},
 
 	computed: {
-		...mapState(useTablesStore, ['activeTable', 'activeView']),
 		allRelations() {
 			const dataStore = useDataStore()
-			return dataStore.getRelations(this.column.id) || {}
+			return dataStore.getRelations(this.column.id).values || {}
 		},
 		currentOption() {
 			if (!this.value) {
@@ -86,12 +83,13 @@ export default {
 			return this.allRelations[this.value]
 		},
 		relationLabel() {
-			return this.currentOption ? this.currentOption.label : null
+			return this.currentOption ? this.currentOption.value : null
 		},
 		relationOptions() {
-			const activeElement = this.activeView || this.activeTable
-			if (activeElement) {
-				return Object.values(this.allRelations || {}).map(option => ({ ...option, id: parseInt(option.id) }))
+			const loading = useDataStore().getRelations(this.column.id).loading
+			if (!loading) {
+				return Object.values(this.allRelations || {})
+					.map(relation => ({ id: relation.id, label: relation.value }))
 			}
 			return []
 		},
@@ -126,17 +124,6 @@ export default {
 			event.stopPropagation()
 		},
 
-		startEditing() {
-			if (!this.canEditCell()) {
-				return false
-			}
-			this.isEditing = true
-			this.editValue = this.value ? parseInt(this.value) : null
-			this.$nextTick(() => {
-				this.$refs.editingContainer?.focus()
-			})
-		},
-
 		async saveChanges() {
 			if (this.localLoading) {
 				return
diff --git a/src/shared/components/ncTable/partials/TableRow.vue b/src/shared/components/ncTable/partials/TableRow.vue
index f350d031e1..4b164744eb 100644
--- a/src/shared/components/ncTable/partials/TableRow.vue
+++ b/src/shared/components/ncTable/partials/TableRow.vue
@@ -26,7 +26,7 @@
 				:value="getCellValue(col)"
 				:element-id="elementId"
 				:is-view="isView"
-				:can-edit="config.canEditRows" />
+				:can-edit="canEditColumn(col)" />
 		</td>
 		<td v-if="config.showActions && (config.canEditRows || config.canDeleteRows || config.canCreateRows)"
 			:class="{sticky: config.showActions}">
@@ -69,7 +69,7 @@ import ContentCopy from 'vue-material-design-icons/ContentCopy.vue'
 import Pencil from 'vue-material-design-icons/PencilOutline.vue'
 import TrashCanOutline from 'vue-material-design-icons/TrashCanOutline.vue'
 import { getTableCellComponent } from './TableCell.js'
-import { getColumnWidthStyle, getFrozenColumnStyle } from './../mixins/columnHandler.js'
+import { ColumnTypes, getColumnWidthStyle, getFrozenColumnStyle } from './../mixins/columnHandler.js'
 import { translate as t } from '@nextcloud/l10n'
 import {
 	TYPE_META_ID, TYPE_META_CREATED_BY, TYPE_META_CREATED_AT, TYPE_META_UPDATED_BY, TYPE_META_UPDATED_AT,
@@ -148,6 +148,7 @@ export default {
 		// to be used to trigger the edit modal instead of inline editing
 		nonInlineEditableColumnTypes() {
 			return [
+				ColumnTypes.Lookup,
 			]
 		},
 	},
@@ -156,9 +157,12 @@ export default {
 		getColumnWidthStyle,
 		getFrozenColumnStyle,
 		getTableCellComponent,
+		canEditColumn(column) {
+			return this.config.canEditRows && !column.isVirtual()
+		},
 		handleCellClick(column) {
 			// If the column type doesn't support inline editing, trigger the edit modal
-			if (this.nonInlineEditableColumnTypes.includes(column.type) && this.config.canEditRows) {
+			if (this.nonInlineEditableColumnTypes.includes(column.type) && this.canEditColumn(column)) {
 				this.$emit('edit-row', this.row.id)
 			}
 		},
@@ -193,7 +197,7 @@ export default {
 			}
 
 			// lets see if we have a value
-			const cell = this.getCell(column.id)
+			const cell = this.getCell(column.getValueColumnId())
 			let value
 
 			if (cell) {
diff --git a/src/shared/components/ncTable/partials/columnTypePartials/forms/LookupForm.vue b/src/shared/components/ncTable/partials/columnTypePartials/forms/LookupForm.vue
new file mode 100644
index 0000000000..9e66707beb
--- /dev/null
+++ b/src/shared/components/ncTable/partials/columnTypePartials/forms/LookupForm.vue
@@ -0,0 +1,175 @@
+<!--
+  - SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+  - SPDX-License-Identifier: AGPL-3.0-or-later
+-->
+<template>
+	<div style="width: 100%">
+		<p>{{ t('tables', 'Displays a column from a linked row. Lookup values are read-only.') }}</p>
+		<div class="row space-T">
+			<div class="fix-col-4 title">
+				{{ t('tables', 'Relation column') }}
+			</div>
+			<div class="fix-col-4">
+				<NcSelect v-model="customSettings.relationColumnId"
+					:options="relationColumns"
+					:reduce="(option) => option.id"
+					:loading="loadingRelationColumns"
+					:aria-label-combobox="t('tables', 'Select relation column')"
+					required
+					@update:model-value="onRelationColumnChange" />
+			</div>
+		</div>
+
+		<div class="row space-T">
+			<div class="fix-col-4 title">
+				{{ t('tables', 'Column to display') }}
+			</div>
+			<div class="fix-col-4">
+				<NcSelect v-model="customSettings.targetColumnId"
+					:options="targetColumns"
+					:reduce="(option) => option.id"
+					:loading="loadingTargetColumns"
+					:disabled="!selectedRelationColumn || loadingTargetColumns"
+					:aria-label-combobox="t('tables', 'Select target column')"
+					required
+					@update:model-value="onTargetColumnChange" />
+			</div>
+		</div>
+	</div>
+</template>
+
+<script>
+import { NcSelect } from '@nextcloud/vue'
+import { translate as t } from '@nextcloud/l10n'
+import { mapState } from 'pinia'
+import { useTablesStore } from '../../../../../../store/store.js'
+import { useDataStore } from '../../../../../../store/data.js'
+import { ColumnTypes } from '../../../mixins/columnHandler.js'
+
+export default {
+	name: 'LookupForm',
+	components: {
+		NcSelect,
+	},
+	props: {
+		column: {
+			type: Object,
+			required: true,
+		},
+	},
+	emits: [
+		'update:customSettings',
+		'update:canSave',
+	],
+	data() {
+		return {
+			customSettings: {
+				relationColumnId: this.column.customSettings?.relationColumnId ?? null,
+				targetColumnId: this.column.customSettings?.targetColumnId ?? null,
+			},
+			relationColumns: [],
+			targetColumns: [],
+			loadingRelationColumns: false,
+			loadingTargetColumns: false,
+		}
+	},
+	computed: {
+		...mapState(useTablesStore, ['activeTable', 'activeView']),
+		canSave() {
+			return !!this.selectedRelationColumn && !!this.selectedTargetColumn && !this.loadingRelationColumns && !this.loadingTargetColumns
+		},
+		selectedRelationColumn() {
+			if (!this.customSettings.relationColumnId) {
+				return null
+			}
+			return this.relationColumns.find(c => c.id === this.customSettings.relationColumnId) || null
+		},
+		selectedTargetColumn() {
+			if (!this.customSettings.targetColumnId) {
+				return null
+			}
+			return this.targetColumns.find(c => c.id === this.customSettings.targetColumnId) || null
+		},
+	},
+	watch: {
+		canSave: {
+			immediate: true,
+			handler(canSave) { this.$emit('update:canSave', canSave) },
+		},
+	},
+	async mounted() {
+		await this.loadRelationColumns()
+		if (this.customSettings.relationColumnId) {
+			await this.loadTargetColumns()
+		}
+		if (!this.column.customSettings?.relationColumnId) {
+			this.updateCustomSettings()
+		}
+	},
+	methods: {
+		t,
+		async loadRelationColumns() {
+			this.loadingRelationColumns = true
+			try {
+				const dataStore = useDataStore()
+				const tableId = this.column.tableId ?? this.activeTable?.id ?? this.activeView?.tableId
+				if (!tableId) {
+					this.relationColumns = []
+					return
+				}
+				let columns = dataStore.getColumns(false, tableId)
+				if (!columns.length) {
+					columns = await dataStore.getColumnsFromBE({ tableId, viewId: this.activeView?.id })
+				}
+
+				this.relationColumns = columns
+					.filter(column => column.type === ColumnTypes.Relation)
+					.map(column => ({
+						id: column.id,
+						label: column.title,
+						column,
+					}))
+			} finally {
+				this.loadingRelationColumns = false
+			}
+		},
+		async loadTargetColumns() {
+			this.targetColumns = []
+			const relationColumnId = this.customSettings.relationColumnId
+			const relationSettings = this.selectedRelationColumn?.column?.customSettings
+			if (!relationSettings) {
+				this.loadingTargetColumns = false
+				return
+			}
+
+			this.loadingTargetColumns = true
+			try {
+				const dataStore = useDataStore()
+				let columns = await dataStore.getColumnsFromBE({
+					tableId: relationSettings.relationType === 'table' ? relationSettings.targetId : null,
+					viewId: relationSettings.relationType === 'view' ? relationSettings.targetId : null,
+				})
+				if (relationColumnId !== this.customSettings.relationColumnId) return
+				const existingTarget = dataStore.getRelations(this.column.id).column
+				if (!columns.length && existingTarget?.id === this.customSettings.targetColumnId) columns = [existingTarget]
+				this.targetColumns = columns
+					.filter(column => column.id > 0 && column.type !== ColumnTypes.Relation && !column.isVirtual())
+					.map(column => ({ id: column.id, label: column.title }))
+			} finally {
+				if (relationColumnId === this.customSettings.relationColumnId) this.loadingTargetColumns = false
+			}
+		},
+		async onRelationColumnChange() {
+			this.customSettings.targetColumnId = null
+			this.updateCustomSettings()
+			await this.loadTargetColumns()
+		},
+		onTargetColumnChange() {
+			this.updateCustomSettings()
+		},
+		updateCustomSettings() {
+			this.$emit('update:customSettings', { ...this.customSettings })
+		},
+	},
+}
+</script>
diff --git a/src/shared/components/ncTable/partials/columnTypePartials/forms/MainForm.vue b/src/shared/components/ncTable/partials/columnTypePartials/forms/MainForm.vue
index 77a96cd72f..6bfa8485b2 100644
--- a/src/shared/components/ncTable/partials/columnTypePartials/forms/MainForm.vue
+++ b/src/shared/components/ncTable/partials/columnTypePartials/forms/MainForm.vue
@@ -29,7 +29,7 @@
 			{{ t('tables', 'Mandatory') }}
 		</div>
 		<div class="fix-col-4">
-			<NcCheckboxRadioSwitch v-model="localMandatory" type="switch" />
+			<NcCheckboxRadioSwitch v-model="localMandatory" type="switch" :disabled="mandatoryDisabled" />
 		</div>
 
 		<!-- add to views -->
@@ -148,6 +148,10 @@ export default {
 			type: Boolean,
 			default: null,
 		},
+		mandatoryDisabled: {
+			type: Boolean,
+			default: false,
+		},
 		technicalName: {
 			type: String,
 			default: null,
@@ -214,7 +218,7 @@ export default {
 			set(technicalName) { this.$emit('update:technicalName', technicalName) },
 		},
 		localMandatory: {
-			get() { return this.mandatory },
+			get() { return !this.mandatoryDisabled && this.mandatory },
 			set(mandatory) { this.$emit('update:mandatory', mandatory) },
 		},
 		localSelectedViews: {
@@ -237,6 +241,12 @@ export default {
 		},
 	},
 	watch: {
+		mandatoryDisabled: {
+			immediate: true,
+			handler(disabled) {
+				if (disabled && this.mandatory) this.$emit('update:mandatory', false)
+			},
+		},
 		technicalNameInvalidError: 'expandAdvancedOnError',
 		widthInvalidError: 'expandAdvancedOnError',
 	},
diff --git a/src/shared/components/ncTable/partials/rowTypePartials/LookupForm.vue b/src/shared/components/ncTable/partials/rowTypePartials/LookupForm.vue
new file mode 100644
index 0000000000..0e0581cd8b
--- /dev/null
+++ b/src/shared/components/ncTable/partials/rowTypePartials/LookupForm.vue
@@ -0,0 +1,32 @@
+<!--
+  - SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+  - SPDX-License-Identifier: AGPL-3.0-or-later
+-->
+<template>
+	<RowFormWrapper :title="column.title" :mandatory="false" :description="column.description" :readonly="true">
+		<TableCellLookup :column="column" :value="value" />
+	</RowFormWrapper>
+</template>
+
+<script>
+import RowFormWrapper from './RowFormWrapper.vue'
+import TableCellLookup from '../TableCellLookup.vue'
+
+export default {
+	name: 'LookupForm',
+	components: {
+		RowFormWrapper,
+		TableCellLookup,
+	},
+	props: {
+		column: {
+			type: Object,
+			required: true,
+		},
+		value: {
+			type: [String, Number, Object],
+			default: null,
+		},
+	},
+}
+</script>
diff --git a/src/shared/components/ncTable/partials/rowTypePartials/RelationForm.vue b/src/shared/components/ncTable/partials/rowTypePartials/RelationForm.vue
index 5aa6377858..7cebacb8a0 100644
--- a/src/shared/components/ncTable/partials/rowTypePartials/RelationForm.vue
+++ b/src/shared/components/ncTable/partials/rowTypePartials/RelationForm.vue
@@ -52,7 +52,7 @@ export default {
 		loading() {
 			const dataStore = useDataStore()
 			const elementId = this.activeView?.id ?? this.activeTable?.id ?? this.column?.tableId
-			if (elementId) {
+			if (elementId || dataStore.publicToken) {
 				return dataStore.getRelationsLoading(!!this.activeView, elementId)
 			}
 			return false
@@ -60,7 +60,8 @@ export default {
 		relationOptions() {
 			const dataStore = useDataStore()
 			const columnRelations = dataStore.getRelations(this.column?.id)
-			return Object.values(columnRelations)
+			return Object.values(columnRelations.values || {})
+				.map(relation => ({ id: relation.id, label: relation.value }))
 		},
 		localValue: {
 			get() {
@@ -74,7 +75,7 @@ export default {
 	async mounted() {
 		const viewId = this.activeView?.id ?? null
 		const tableId = this.activeTable?.id ?? this.column?.tableId ?? null
-		if (viewId || tableId) {
+		if (viewId || tableId || useDataStore().publicToken) {
 			await this.loadRelationsFromBE({
 				tableId,
 				viewId,
diff --git a/src/shared/utils/columnUtils.js b/src/shared/utils/columnUtils.js
index 768a77b381..dddfd36e35 100644
--- a/src/shared/utils/columnUtils.js
+++ b/src/shared/utils/columnUtils.js
@@ -2,6 +2,18 @@
  * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
+import { ColumnTypes } from '../components/ncTable/mixins/columnHandler.js'
+
+/**
+ * Whether the column is virtual, i.e. it does not store its own cell data.
+ * For plain column objects only — AbstractColumn instances provide isVirtual().
+ *
+ * @param {object|null|undefined} column the column to check
+ * @return {boolean}
+ */
+export function isVirtualColumn(column) {
+	return column?.type === ColumnTypes.Lookup
+}
 
 /**
  * @param {string|null|undefined} technicalName the raw technical name to normalize
diff --git a/src/store/data.js b/src/store/data.js
index ff5b41ccbd..4cddb2035d 100644
--- a/src/store/data.js
+++ b/src/store/data.js
@@ -8,6 +8,7 @@ import { generateUrl, generateOcsUrl } from '@nextcloud/router'
 import displayError from '../shared/utils/displayError.js'
 import { parseCol } from '../shared/components/ncTable/mixins/columnParser.js'
 import { MetaColumns } from '../shared/components/ncTable/mixins/metaColumns.js'
+import { ColumnTypes } from '../shared/components/ncTable/mixins/columnHandler.js'
 import { showError } from '@nextcloud/dialogs'
 import { emit } from '@nextcloud/event-bus'
 import { getCurrentUser } from '@nextcloud/auth'
@@ -36,6 +37,8 @@ export const useDataStore = defineStore('data', {
 		publicToken: null,
 		relations: {},
 		relationsLoading: {},
+		relationsLoaded: {},
+		relationColumnIds: {},
 	}),
 
 	getters: {
@@ -58,7 +61,7 @@ export const useDataStore = defineStore('data', {
 			return state.relations[columnId]
 		},
 		getRelationsLoading: (state) => (isView, elementId) => {
-			const stateId = genStateKey(isView, elementId)
+			const stateId = state.publicToken ? 'public-' + state.publicToken : genStateKey(isView, elementId)
 			return state.relationsLoading[stateId] === true
 		},
 	},
@@ -71,6 +74,8 @@ export const useDataStore = defineStore('data', {
 			this.publicToken = null
 			this.relations = {}
 			this.relationsLoading = {}
+			this.relationsLoaded = {}
+			this.relationColumnIds = {}
 		},
 
 		setPublicToken(token) {
@@ -197,6 +202,9 @@ export const useDataStore = defineStore('data', {
 			if (stateId) {
 				this.columns[stateId].push(parseCol(res.data))
 				this.loading[stateId] = false
+				if ([ColumnTypes.Relation, ColumnTypes.Lookup].includes(res.data.type)) {
+					await this.loadRelationsFromBE({ tableId: isView ? null : elementId, viewId: isView ? elementId : null, force: true })
+				}
 			}
 			return true
 		},
@@ -217,7 +225,10 @@ export const useDataStore = defineStore('data', {
 			if (stateId && this.columns[stateId]) {
 				const col = res.data
 				const index = this.columns[stateId].findIndex(c => c.id === col.id)
-				this.columns[stateId][index] = parseCol(col)
+				if (index !== -1) this.columns[stateId][index] = parseCol(col)
+				if ([ColumnTypes.Relation, ColumnTypes.Lookup].includes(col.type)) {
+					await this.loadRelationsFromBE({ tableId: isView ? null : elementId, viewId: isView ? elementId : null, force: true })
+				}
 			}
 
 			return true
@@ -233,42 +244,57 @@ export const useDataStore = defineStore('data', {
 
 			const stateId = genStateKey(isView, elementId)
 			if (stateId && this.columns[stateId]) {
+				const column = this.columns[stateId].find(c => c.id === id)
 				const filteredColumns = this.columns[stateId].filter(c => c.id !== id)
 				this.columns[stateId] = filteredColumns
+				if ([ColumnTypes.Relation, ColumnTypes.Lookup].includes(column?.type)) {
+					await this.loadRelationsFromBE({ tableId: isView ? null : elementId, viewId: isView ? elementId : null, force: true })
+				}
 			}
 
 			return true
 		},
 
 		// RELATIONS
-		async loadRelationsFromBE({ tableId, viewId, force = false }) {
-			const stateId = genStateKey(!!(viewId), viewId ?? tableId)
+		async loadRelationsFromBE({ tableId, viewId, token = this.publicToken, force = false }) {
+			const stateId = token ? 'public-' + token : genStateKey(!!viewId, viewId ?? tableId)
 
 			// prevent double-loading
-			if (this.relationsLoading[stateId] === true || (this.relationsLoading[stateId] === false && !force)) {
+			if (this.relationsLoading[stateId] || (this.relationsLoaded[stateId] && !force)) {
 				return
 			}
 
 			this.relationsLoading[stateId] = true
-
-			let res = null
+			const columnIds = new Set([
+				...(this.relationColumnIds[stateId] ?? []),
+				...(this.columns[stateId] ?? [])
+					.filter(column => [ColumnTypes.Relation, ColumnTypes.Lookup].includes(column.type))
+					.map(column => String(column.id)),
+			])
+			columnIds.forEach(id => { this.relations[id] = { ...this.getRelations(id), loading: true } })
 
 			try {
-				if (viewId) {
-					res = await axios.get(generateUrl('/apps/tables/api/1/views/' + viewId + '/relations'))
-				} else {
-					res = await axios.get(generateUrl('/apps/tables/api/1/tables/' + tableId + '/relations'))
-				}
+				const url = token
+					? generateOcsUrl('/apps/tables/api/2/public/' + token + '/relations')
+					: generateUrl('/apps/tables/api/1/' + (viewId ? 'views/' + viewId : 'tables/' + tableId) + '/relations')
+				const res = await axios.get(url)
+				const data = token ? res.data.ocs.data : res.data
+				const parsed = Object.fromEntries(Object.entries(data).map(([columnId, relations]) => [columnId, {
+					...relations,
+					column: relations.column ? parseCol(relations.column) : null,
+					loading: false,
+				}]))
+				columnIds.forEach(id => { this.relations[id] = parsed[id] ?? { column: null, values: {}, loading: false } })
+				Object.assign(this.relations, parsed)
+				this.relationColumnIds[stateId] = Object.keys(parsed)
+				this.relationsLoaded[stateId] = true
 			} catch (e) {
+				columnIds.forEach(id => { this.relations[id] = { column: null, values: {}, loading: false } })
+				this.relationsLoaded[stateId] = false
 				displayError(e, t('tables', 'Could not load relation data.'))
+			} finally {
 				this.relationsLoading[stateId] = false
-				return {}
 			}
-
-			Object.entries(res.data).forEach(([columnId, relations]) => {
-				this.relations[columnId] = relations
-			})
-			this.relationsLoading[stateId] = false
 		},
 
 		// ROWS
diff --git a/src/types/openapi/openapi.ts b/src/types/openapi/openapi.ts
index 2c3d2b29ab..4f1b00eb52 100644
--- a/src/types/openapi/openapi.ts
+++ b/src/types/openapi/openapi.ts
@@ -332,6 +332,46 @@ export type paths = {
         readonly patch?: never;
         readonly trace?: never;
     };
+    readonly "/index.php/apps/tables/api/1/tables/{tableId}/relations": {
+        readonly parameters: {
+            readonly query?: never;
+            readonly header?: never;
+            readonly path?: never;
+            readonly cookie?: never;
+        };
+        /**
+         * Get all relation data for a table
+         * @description This endpoint allows CORS requests
+         */
+        readonly get: operations["api1-index-table-relations"];
+        readonly put?: never;
+        readonly post?: never;
+        readonly delete?: never;
+        readonly options?: never;
+        readonly head?: never;
+        readonly patch?: never;
+        readonly trace?: never;
+    };
+    readonly "/index.php/apps/tables/api/1/views/{viewId}/relations": {
+        readonly parameters: {
+            readonly query?: never;
+            readonly header?: never;
+            readonly path?: never;
+            readonly cookie?: never;
+        };
+        /**
+         * Get all relation data for a view
+         * @description This endpoint allows CORS requests
+         */
+        readonly get: operations["api1-index-view-relations"];
+        readonly put?: never;
+        readonly post?: never;
+        readonly delete?: never;
+        readonly options?: never;
+        readonly head?: never;
+        readonly patch?: never;
+        readonly trace?: never;
+    };
     readonly "/index.php/apps/tables/api/1/tables/{tableId}/rows/simple": {
         readonly parameters: {
             readonly query?: never;
@@ -1137,10 +1177,20 @@ export type components = {
             } | null;
             readonly customSettings: {
                 /** Format: int64 */
-                readonly width: number;
+                readonly width?: number;
                 readonly showPreview?: boolean;
                 /** Format: int64 */
                 readonly imagePreviewSize?: number;
+                /** @enum {string} */
+                readonly relationType?: "table" | "view";
+                /** Format: int64 */
+                readonly targetId?: number;
+                /** Format: int64 */
+                readonly labelColumn?: number;
+                /** Format: int64 */
+                readonly relationColumnId?: number;
+                /** Format: int64 */
+                readonly targetColumnId?: number;
             } | null;
         };
         readonly Context: {
@@ -1245,10 +1295,20 @@ export type components = {
             } | null;
             readonly customSettings: {
                 /** Format: int64 */
-                readonly width: number;
+                readonly width?: number;
                 readonly showPreview?: boolean;
                 /** Format: int64 */
                 readonly imagePreviewSize?: number;
+                /** @enum {string} */
+                readonly relationType?: "table" | "view";
+                /** Format: int64 */
+                readonly targetId?: number;
+                /** Format: int64 */
+                readonly labelColumn?: number;
+                /** Format: int64 */
+                readonly relationColumnId?: number;
+                /** Format: int64 */
+                readonly targetColumnId?: number;
             } | null;
         };
         readonly PublicRow: {
@@ -1269,6 +1329,24 @@ export type components = {
                 };
             };
         };
+        readonly RelationData: {
+            readonly [key: string]: {
+                readonly column: components["schemas"]["Column"] | null;
+                readonly values: {
+                    readonly [key: string]: {
+                        /** Format: int64 */
+                        readonly id: number;
+                        readonly value: components["schemas"]["RelationValue"];
+                    };
+                } | readonly unknown[];
+            };
+        } | readonly unknown[];
+        readonly RelationValue: (string | number | boolean | readonly (number | string)[] | readonly {
+            readonly id: string;
+            /** Format: int64 */
+            readonly type: number;
+            readonly displayName: string;
+        }[]) | null;
         readonly Row: {
             /** Format: int64 */
             readonly id: number;
@@ -2970,7 +3048,7 @@ export interface operations {
                      * @description Column main type
                      * @enum {string}
                      */
-                    readonly type: "text" | "number" | "datetime" | "select" | "usergroup" | "relation";
+                    readonly type: "text" | "number" | "datetime" | "select" | "usergroup" | "relation" | "lookup";
                     /** @description Column sub type */
                     readonly subtype?: string | null;
                     /** @description Is the column mandatory */
@@ -3232,7 +3310,7 @@ export interface operations {
                      * @description Column main type
                      * @enum {string}
                      */
-                    readonly type: "text" | "number" | "datetime" | "select" | "usergroup" | "relation";
+                    readonly type: "text" | "number" | "datetime" | "select" | "usergroup" | "relation" | "lookup";
                     /** @description Column sub type */
                     readonly subtype?: string | null;
                     /** @description Is the column mandatory */
@@ -3547,11 +3625,11 @@ export interface operations {
                     readonly usergroupShowUserStatus?: boolean | null;
                     /**
                      * @description Custom settings for the column
-                     * @default {}
+                     * @default null
                      */
                     readonly customSettings?: {
                         readonly [key: string]: Record<string, never>;
-                    };
+                    } | null;
                 };
             };
         };
@@ -3666,6 +3744,138 @@ export interface operations {
             };
         };
     };
+    readonly "api1-index-table-relations": {
+        readonly parameters: {
+            readonly query?: never;
+            readonly header?: never;
+            readonly path: {
+                /** @description Table ID */
+                readonly tableId: number;
+            };
+            readonly cookie?: never;
+        };
+        readonly requestBody?: never;
+        readonly responses: {
+            /** @description Relation data returned */
+            readonly 200: {
+                headers: {
+                    readonly [name: string]: unknown;
+                };
+                content: {
+                    readonly "application/json": components["schemas"]["RelationData"];
+                };
+            };
+            /** @description Current user is not logged in */
+            readonly 401: {
+                headers: {
+                    readonly [name: string]: unknown;
+                };
+                content: {
+                    readonly "application/json": {
+                        readonly message: string;
+                    };
+                };
+            };
+            /** @description No permissions */
+            readonly 403: {
+                headers: {
+                    readonly [name: string]: unknown;
+                };
+                content: {
+                    readonly "application/json": {
+                        readonly message: string;
+                    };
+                };
+            };
+            /** @description Not found */
+            readonly 404: {
+                headers: {
+                    readonly [name: string]: unknown;
+                };
+                content: {
+                    readonly "application/json": {
+                        readonly message: string;
+                    };
+                };
+            };
+            readonly 500: {
+                headers: {
+                    readonly [name: string]: unknown;
+                };
+                content: {
+                    readonly "application/json": {
+                        readonly message: string;
+                    };
+                };
+            };
+        };
+    };
+    readonly "api1-index-view-relations": {
+        readonly parameters: {
+            readonly query?: never;
+            readonly header?: never;
+            readonly path: {
+                /** @description View ID */
+                readonly viewId: number;
+            };
+            readonly cookie?: never;
+        };
+        readonly requestBody?: never;
+        readonly responses: {
+            /** @description Relation data returned */
+            readonly 200: {
+                headers: {
+                    readonly [name: string]: unknown;
+                };
+                content: {
+                    readonly "application/json": components["schemas"]["RelationData"];
+                };
+            };
+            /** @description Current user is not logged in */
+            readonly 401: {
+                headers: {
+                    readonly [name: string]: unknown;
+                };
+                content: {
+                    readonly "application/json": {
+                        readonly message: string;
+                    };
+                };
+            };
+            /** @description No permissions */
+            readonly 403: {
+                headers: {
+                    readonly [name: string]: unknown;
+                };
+                content: {
+                    readonly "application/json": {
+                        readonly message: string;
+                    };
+                };
+            };
+            /** @description Not found */
+            readonly 404: {
+                headers: {
+                    readonly [name: string]: unknown;
+                };
+                content: {
+                    readonly "application/json": {
+                        readonly message: string;
+                    };
+                };
+            };
+            readonly 500: {
+                headers: {
+                    readonly [name: string]: unknown;
+                };
+                content: {
+                    readonly "application/json": {
+                        readonly message: string;
+                    };
+                };
+            };
+        };
+    };
     readonly "api1-index-table-rows-simple": {
         readonly parameters: {
             readonly query?: {
diff --git a/src/views/ContentReferenceWidget.vue b/src/views/ContentReferenceWidget.vue
index c37494b2ce..a68d52d668 100644
--- a/src/views/ContentReferenceWidget.vue
+++ b/src/views/ContentReferenceWidget.vue
@@ -63,6 +63,8 @@ import { spawnDialog } from '@nextcloud/vue/functions/dialog'
 import { useTablesStore } from '../store/store.js'
 import { useDataStore } from '../store/data.js'
 import { NODE_TYPE_VIEW } from '../shared/constants.ts'
+import { parseCol } from '../shared/components/ncTable/mixins/columnParser.js'
+import { AbstractColumn } from '../shared/components/ncTable/mixins/columnClass.js'
 
 export default {
 
@@ -159,7 +161,8 @@ export default {
 			if (storeColumns && storeColumns.length > 0) {
 				return storeColumns
 			}
-			return this.richObject?.columns || []
+			return (this.richObject?.columns || [])
+				.map(col => (col instanceof AbstractColumn || col.id < 0) ? col : parseCol(col))
 		},
 	},
 
diff --git a/tests/integration/features/APIv1.feature b/tests/integration/features/APIv1.feature
index 925ce4c1ae..8fbf11b611 100644
--- a/tests/integration/features/APIv1.feature
+++ b/tests/integration/features/APIv1.feature
@@ -761,6 +761,7 @@ Feature: APIv1
       | name      | Cherry |
       | available | true   |
     When user "participant1" create view "Available Fruits" with emoji "✅" for "fruits" as "available-fruits"
+    And user "participant1" sets columnSettings "name,available" to view "available-fruits"
     And user "participant1" sets filter to view "available-fruits"
       | column    | operator | value |
       | available | is-equal | true  |
@@ -804,6 +805,66 @@ Feature: APIv1
     When user "participant2" fetches relations for table "secret-orders"
     Then the reported status is "404"
 
+  @api1 @relation @lookup
+  Scenario: Create a lookup column and fetch relations for a table
+    Given table "Products" with emoji "📦" exists for user "participant1" as "products"
+    Then column "name" exists with following properties
+      | type      | text |
+      | subtype   | line |
+      | mandatory | 0    |
+    Then column "category" exists with following properties
+      | type      | text |
+      | subtype   | line |
+      | mandatory | 0    |
+    Then row exists with following values
+      | name     | Apple  |
+      | category | Fruit  |
+    Then row exists with following values
+      | name     | Banana |
+      | category | Berry  |
+    Given table "Orders" with emoji "🛒" exists for user "participant1" as "orders"
+    Then relation column "product" exists on table "orders" pointing to table "products" using label column "name"
+    Then lookup column "product category" exists on table "orders" for relation column "product" using target column "category"
+    When user "participant1" fetches relations for table "orders"
+    Then the reported status is "200"
+    Then the relations response contains 2 entries for column "product"
+    Then the relations response for column "product" has an entry with label "Apple"
+    Then the relations response for column "product" has an entry with label "Banana"
+    Then the relations response contains 2 entries for column "product category"
+    Then the relations response for column "product category" has an entry with value "Fruit"
+    Then the relations response for column "product category" has an entry with value "Berry"
+
+  @api1 @relation @lookup
+  Scenario: Create a lookup column for a relation pointing to a view
+    Given table "Fruits" with emoji "🍎" exists for user "participant1" as "fruits"
+    Then column "name" exists with following properties
+      | type      | text |
+      | subtype   | line |
+      | mandatory | 0    |
+    Then column "color" exists with following properties
+      | type      | text |
+      | subtype   | line |
+      | mandatory | 0    |
+    Then row exists with following values
+      | name  | Apple  |
+      | color | Red    |
+    Then row exists with following values
+      | name  | Banana |
+      | color | Yellow |
+    When user "participant1" create view "Fruit View" with emoji "👁" for "fruits" as "fruit-view"
+    And user "participant1" sets columnSettings "name,color" to view "fruit-view"
+    Given table "Baskets" with emoji "🧺" exists for user "participant1" as "baskets"
+    Then relation column "fruit" exists on table "baskets" pointing to view "fruit-view" using label column "name"
+    Then lookup column "fruit color" exists on table "baskets" for relation column "fruit" using target column "color"
+    When user "participant1" fetches relations for table "baskets"
+    Then the reported status is "200"
+    Then the relations response contains 2 entries for column "fruit"
+    Then the relations response for column "fruit" has an entry with label "Apple"
+    Then the relations response for column "fruit" has an entry with label "Banana"
+    Then the relations response contains 2 entries for column "fruit color"
+    Then the relations response for column "fruit color" has an entry with value "Red"
+    Then the relations response for column "fruit color" has an entry with value "Yellow"
+
   @api1 @columns @rows
   Scenario: Column technicalName is returned and dataByAlias maps alias to row values
     Given table "Alias test" with emoji "🔖" exists for user "participant1" as "base1"
diff --git a/tests/integration/features/bootstrap/FeatureContext.php b/tests/integration/features/bootstrap/FeatureContext.php
index 37a5fdea98..627acdb19e 100644
--- a/tests/integration/features/bootstrap/FeatureContext.php
+++ b/tests/integration/features/bootstrap/FeatureContext.php
@@ -2695,6 +2695,74 @@ public function createRelationColumnToView(string $title, string $tableName, str
 		$this->collectionManager->register($newColumn, 'column', $newColumn['id'], $title);
 	}
 
+	/**
+	 * @Then lookup column :title exists on table :tableName for relation column :relationColumnName using target column :targetColumnName
+	 */
+	public function createLookupColumn(string $title, string $tableName, string $relationColumnName, string $targetColumnName): void {
+		$relationColumnId = (int)$this->collectionManager->getByAlias('column', $relationColumnName)['id'];
+		$targetColumnId = (int)$this->collectionManager->getByAlias('column', $targetColumnName)['id'];
+
+		$props = [
+			'title' => $title,
+			'type' => 'lookup',
+			'mandatory' => 0,
+			'customSettings' => [
+				'relationColumnId' => $relationColumnId,
+				'targetColumnId' => $targetColumnId,
+			],
+		];
+
+		$this->sendRequest(
+			'POST',
+			'/apps/tables/api/1/tables/' . $this->tableIds[$tableName] . '/columns',
+			$props
+		);
+
+		$newColumn = $this->getDataFromResponse($this->response);
+		$this->columnId = $newColumn['id'];
+
+		Assert::assertEquals(200, $this->response->getStatusCode());
+		Assert::assertEquals($title, $newColumn['title']);
+		Assert::assertEquals('lookup', $newColumn['type']);
+
+		$this->collectionManager->register($newColumn, 'column', $newColumn['id'], $title);
+	}
+
+	/**
+	 * @Then lookup column :title exists on table :tableName for relation column :relationColumnName using target column :targetColumnName added to view :viewName
+	 */
+	public function createLookupColumnAddedToView(string $title, string $tableName, string $relationColumnName, string $targetColumnName, string $viewName): void {
+		$relationColumnId = (int)$this->collectionManager->getByAlias('column', $relationColumnName)['id'];
+		$targetColumnId = (int)$this->collectionManager->getByAlias('column', $targetColumnName)['id'];
+		$viewId = $this->viewIds[$viewName];
+
+		$props = [
+			'title' => $title,
+			'type' => 'lookup',
+			'mandatory' => 0,
+			'selectedViewIds' => [$viewId],
+			'customSettings' => [
+				'relationColumnId' => $relationColumnId,
+				'targetColumnId' => $targetColumnId,
+			],
+		];
+
+		$this->sendRequest(
+			'POST',
+			'/apps/tables/api/1/tables/' . $this->tableIds[$tableName] . '/columns',
+			$props
+		);
+
+		$newColumn = $this->getDataFromResponse($this->response);
+		$this->columnId = $newColumn['id'];
+
+		Assert::assertEquals(200, $this->response->getStatusCode());
+		Assert::assertEquals($title, $newColumn['title']);
+		Assert::assertEquals('lookup', $newColumn['type']);
+
+		$this->collectionManager->register($newColumn, 'column', $newColumn['id'], $title);
+	}
+
 	/**
 	 * @When user :user fetches relations for table :tableName
 	 */
@@ -2730,7 +2798,7 @@ public function theRelationsResponseContainsEntriesForColumn(int $count, string
 		Assert::assertNotNull($this->relationsData, 'Relations response was not fetched or returned non-200');
 		$columnId = (int)$this->collectionManager->getByAlias('column', $columnName)['id'];
 		Assert::assertArrayHasKey($columnId, $this->relationsData, 'Column "' . $columnName . '" (id=' . $columnId . ') not found in relations response');
-		Assert::assertCount($count, $this->relationsData[$columnId], 'Expected ' . $count . ' entries for column "' . $columnName . '"');
+		Assert::assertCount($count, $this->relationsData[$columnId]['values'], 'Expected ' . $count . ' entries for column "' . $columnName . '"');
 	}
 
 	/**
@@ -2740,10 +2808,21 @@ public function theRelationsResponseForColumnHasEntryWithLabel(string $columnNam
 		Assert::assertNotNull($this->relationsData, 'Relations response was not fetched or returned non-200');
 		$columnId = (int)$this->collectionManager->getByAlias('column', $columnName)['id'];
 		Assert::assertArrayHasKey($columnId, $this->relationsData, 'Column "' . $columnName . '" not found in relations response');
-		$labels = array_column($this->relationsData[$columnId], 'label');
+		$labels = array_column($this->relationsData[$columnId]['values'], 'value');
 		Assert::assertContains($label, $labels, 'Label "' . $label . '" not found in relations for column "' . $columnName . '"');
 	}
 
+	/**
+	 * @Then the relations response for column :columnName has an entry with value :value
+	 */
+	public function theRelationsResponseForColumnHasEntryWithValue(string $columnName, string $value): void {
+		Assert::assertNotNull($this->relationsData, 'Relations response was not fetched or returned non-200');
+		$columnId = (int)$this->collectionManager->getByAlias('column', $columnName)['id'];
+		Assert::assertArrayHasKey($columnId, $this->relationsData, 'Column "' . $columnName . '" not found in relations response');
+		$values = array_column($this->relationsData[$columnId]['values'], 'value');
+		Assert::assertContains($value, $values, 'Value "' . $value . '" not found in relations for column "' . $columnName . '"');
+	}
+
 	/**
 	 * @Then the relations response is empty
 	 */
diff --git a/tests/unit/Analytics/AnalyticsDatasourceTest.php b/tests/unit/Analytics/AnalyticsDatasourceTest.php
index be20281e93..b7ce83240b 100644
--- a/tests/unit/Analytics/AnalyticsDatasourceTest.php
+++ b/tests/unit/Analytics/AnalyticsDatasourceTest.php
@@ -162,10 +162,10 @@ public function testReadDataFormatsRelationValuesForAnalytics(): void {
 
 		$this->relationService
 			->expects($this->once())
-			->method('getRelationData')
+			->method('getRelationLabels')
 			->willReturn([
-				42 => ['id' => 42, 'label' => 'Acme Corp'],
-				43 => ['id' => 43, 'label' => 'Globex'],
+				42 => ['id' => 42, 'value' => 'Acme Corp'],
+				43 => ['id' => 43, 'value' => 'Globex'],
 			]);
 
 		$row = new Row2();
diff --git a/tests/unit/Db/Row2MapperTestDependencies.php b/tests/unit/Db/Row2MapperTestDependencies.php
index a3dd5c34fb..1e68f3ac9f 100644
--- a/tests/unit/Db/Row2MapperTestDependencies.php
+++ b/tests/unit/Db/Row2MapperTestDependencies.php
@@ -219,6 +219,9 @@ protected function setupRealColumnMapper(int $tableId): void {
 		$this->columnMapper->method('find')
 			->willReturnCallback(fn ($id) => $columns[$id] ?? throw new DoesNotExistException('test'));
 
+		$this->columnMapper->method('findAll')
+			->willReturnCallback(fn (array $ids) => array_values(array_intersect_key($columns, array_flip($ids))));
+
 		$this->columnMapper->method('preloadColumns');
 		$this->columnMapper->method('getColumnTypes')->willReturn($columnTypes);
 	}
diff --git a/tests/unit/Service/RelationServiceTest.php b/tests/unit/Service/RelationServiceTest.php
new file mode 100644
index 0000000000..ac170aa39c
--- /dev/null
+++ b/tests/unit/Service/RelationServiceTest.php
@@ -0,0 +1,143 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+namespace OCA\Tables\Tests\Unit\Service;
+
+use OCA\Tables\Db\Column;
+use OCA\Tables\Db\ColumnMapper;
+use OCA\Tables\Db\Row2;
+use OCA\Tables\Db\Row2Mapper;
+use OCA\Tables\Db\View;
+use OCA\Tables\Db\ViewMapper;
+use OCA\Tables\Service\ColumnService;
+use OCA\Tables\Service\RelationService;
+use OCP\IUserSession;
+use PHPUnit\Framework\TestCase;
+use Psr\Log\LoggerInterface;
+
+class RelationServiceTest extends TestCase {
+	private ColumnMapper $columnMapper;
+	private ViewMapper $viewMapper;
+	private Row2Mapper $rowMapper;
+	private ColumnService $columnService;
+	private RelationService $service;
+
+	protected function setUp(): void {
+		parent::setUp();
+		$this->columnMapper = $this->createMock(ColumnMapper::class);
+		$this->viewMapper = $this->createMock(ViewMapper::class);
+		$this->rowMapper = $this->createMock(Row2Mapper::class);
+		$this->columnService = $this->createMock(ColumnService::class);
+		$this->service = new RelationService(
+			$this->columnMapper,
+			$this->viewMapper,
+			$this->rowMapper,
+			$this->columnService,
+			$this->createMock(IUserSession::class),
+			$this->createMock(LoggerInterface::class),
+		);
+	}
+
+	private function column(int $id, int $tableId, string $type, array $settings = []): Column {
+		$column = new Column();
+		$column->setId($id);
+		$column->setTableId($tableId);
+		$column->setType($type);
+		$column->setSubtype($type === Column::TYPE_TEXT ? 'line' : '');
+		$column->setTitle('Column ' . $id);
+		$column->setCustomSettings(json_encode($settings));
+		return $column;
+	}
+
+	private function configureColumns(array $columns): void {
+		$columnsMap = [];
+		foreach ($columns as $column) {
+			$columnsMap[$column->getId()] = $column;
+		}
+		$this->columnMapper->method('findAll')->willReturnCallback(
+			fn (array $ids) => array_values(array_intersect_key($columnsMap, array_flip($ids)))
+		);
+		$this->columnMapper->method('find')->willReturnCallback(fn (int $id) => $columnsMap[$id]);
+	}
+
+	public function testLookupsBatchTargetRowsAndKeepRawValuesSeparateFromLabels(): void {
+		$relation = $this->column(7, 1, Column::TYPE_RELATION, ['relationType' => 'table', 'targetId' => 2, 'labelColumn' => 20]);
+		$labelLookup = $this->column(8, 1, Column::TYPE_LOOKUP, ['relationColumnId' => 7, 'targetColumnId' => 20]);
+		$textLookup = $this->column(9, 1, Column::TYPE_LOOKUP, ['relationColumnId' => 7, 'targetColumnId' => 21]);
+		$zeroLookup = $this->column(10, 1, Column::TYPE_LOOKUP, ['relationColumnId' => 7, 'targetColumnId' => 22]);
+		$label = $this->column(20, 2, Column::TYPE_NUMBER);
+		$label->setNumberPrefix('$');
+		$label->setNumberSuffix(' USD');
+		$label->setNumberDecimals(2);
+		$this->configureColumns([$relation, $label, $this->column(21, 2, Column::TYPE_TEXT), $this->column(22, 2, Column::TYPE_NUMBER)]);
+		$this->columnService->method('findAllByTable')->with(1)->willReturn([$relation, $labelLookup, $textLookup, $zeroLookup]);
+
+		$row = new Row2();
+		$row->setId(42);
+		$row->addCell(20, 12.5);
+		$row->addCell(21, 'Fruit');
+		$row->addCell(22, 0);
+		$emptyLabelRow = new Row2();
+		$emptyLabelRow->setId(43);
+		$emptyLabelRow->addCell(21, 'Berry');
+		$this->rowMapper->expects($this->once())->method('findAll')->with(
+			$this->callback(function (array $ids): bool {
+				sort($ids);
+				return $ids === [20, 21, 22];
+			}), 2, null, null, null, null, ''
+		)->willReturn([$row, $emptyLabelRow]);
+
+		$result = $this->service->getRelationsForTable(1);
+		$this->assertSame('$12.50 USD', $result[7]['values'][42]['value']);
+		$this->assertSame(12.5, $result[8]['values'][42]['value']);
+		$this->assertSame(0, $result[10]['values'][42]['value']);
+		$this->assertSame('Berry', $result[9]['values'][43]['value']);
+		$this->assertNull($result[8]['values'][43]['value']);
+		$this->assertSame($result, $this->service->getRelationsForTable(1));
+	}
+
+	public function testLookupOnlySourceViewIncludesItsHiddenRelationDependency(): void {
+		$relation = $this->column(7, 1, Column::TYPE_RELATION, ['relationType' => 'view', 'targetId' => 3, 'labelColumn' => 20]);
+		$lookup = $this->column(8, 1, Column::TYPE_LOOKUP, ['relationColumnId' => 7, 'targetColumnId' => 21]);
+		$this->configureColumns([$relation, $this->column(21, 2, Column::TYPE_TEXT)]);
+		$this->columnService->method('findAllByView')->with(4)->willReturn([$lookup]);
+		$view = new View();
+		$view->setId(3);
+		$view->setTableId(2);
+		$view->setFilter(json_encode([[['columnId' => 20, 'operator' => 'is-not-empty', 'value' => '']]]));
+		$this->viewMapper->method('find')->with(3)->willReturn($view);
+		$row = new Row2();
+		$row->setId(42);
+		$row->addCell(21, 'Berlin');
+		$this->rowMapper->expects($this->once())->method('findAll')
+			->with([21], 2, null, null, $view->getFilterArray(), $view->getSortArray(), '')
+			->willReturn([$row]);
+
+		$result = $this->service->getRelationsForView(4);
+		$this->assertSame([8], array_keys($result));
+		$this->assertSame('Berlin', $result[8]['values'][42]['value']);
+	}
+
+	public function testMissingUnsupportedOrForeignDependenciesReturnUnavailableEntries(): void {
+		$foreignRelation = $this->column(7, 99, Column::TYPE_RELATION, ['relationType' => 'table', 'targetId' => 2, 'labelColumn' => 20]);
+		$foreignLookup = $this->column(8, 1, Column::TYPE_LOOKUP, ['relationColumnId' => 7, 'targetColumnId' => 21]);
+		$missingLookup = $this->column(9, 1, Column::TYPE_LOOKUP, ['relationColumnId' => 70, 'targetColumnId' => 21]);
+		$invalidLookup = $this->column(10, 1, Column::TYPE_LOOKUP);
+		$localRelation = $this->column(11, 1, Column::TYPE_RELATION, ['relationType' => 'table', 'targetId' => 2, 'labelColumn' => 20]);
+		$unsupportedLookup = $this->column(12, 1, Column::TYPE_LOOKUP, ['relationColumnId' => 11, 'targetColumnId' => 23]);
+		$this->configureColumns([$foreignRelation, $localRelation, $this->column(21, 2, Column::TYPE_TEXT), $this->column(23, 2, Column::TYPE_RELATION)]);
+		$this->columnService->method('findAllByTable')->willReturn([$foreignLookup, $missingLookup, $invalidLookup, $unsupportedLookup]);
+		$this->rowMapper->expects($this->never())->method('findAll');
+
+		$result = $this->service->getRelationsForTable(1);
+		foreach ([8, 9, 10, 12] as $id) {
+			$this->assertSame(['column' => null, 'values' => []], $result[$id]);
+		}
+	}
+}