reifydb-catalog 0.4.10

Database catalog and metadata management for ReifyDB
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

// SPDX-License-Identifier: Apache-2.0
// Copyright (c) 2025 ReifyDB

use reifydb_core::{
	encoded::{key::EncodedKey, row::EncodedRow},
	interface::catalog::{
		id::{MigrationEventId, MigrationId},
		migration::{Migration, MigrationAction, MigrationEvent},
	},
	key::{EncodableKey, kind::KeyKind, migration::MigrationKey, migration_event::MigrationEventKey},
};
use reifydb_transaction::transaction::Transaction;

use super::CatalogChangeApplier;
use crate::{
	Result,
	catalog::Catalog,
	error::CatalogChangeError,
	store::migration::shape::{migration, migration_event},
};

pub(super) struct MigrationApplier;

impl CatalogChangeApplier for MigrationApplier {
	fn set(catalog: &Catalog, txn: &mut Transaction<'_>, key: &EncodedKey, row: &EncodedRow) -> Result<()> {
		txn.set(key, row.clone())?;
		let m = decode_migration(row);
		catalog.materialized.set_migration(m.id, txn.version(), Some(m));
		Ok(())
	}

	fn remove(catalog: &Catalog, txn: &mut Transaction<'_>, key: &EncodedKey) -> Result<()> {
		txn.remove(key)?;
		let id = MigrationKey::decode(key).map(|k| k.migration).ok_or(CatalogChangeError::KeyDecodeFailed {
			kind: KeyKind::Migration,
		})?;
		catalog.materialized.set_migration(id, txn.version(), None);
		Ok(())
	}
}

pub(super) struct MigrationEventApplier;

impl CatalogChangeApplier for MigrationEventApplier {
	fn set(catalog: &Catalog, txn: &mut Transaction<'_>, key: &EncodedKey, row: &EncodedRow) -> Result<()> {
		txn.set(key, row.clone())?;
		let evt = decode_migration_event(row);
		catalog.materialized.set_migration_event(evt.id, txn.version(), Some(evt));
		Ok(())
	}

	fn remove(catalog: &Catalog, txn: &mut Transaction<'_>, key: &EncodedKey) -> Result<()> {
		txn.remove(key)?;
		let id =
			MigrationEventKey::decode(key).map(|k| k.event).ok_or(CatalogChangeError::KeyDecodeFailed {
				kind: KeyKind::MigrationEvent,
			})?;
		catalog.materialized.set_migration_event(id, txn.version(), None);
		Ok(())
	}
}

fn decode_migration(row: &EncodedRow) -> Migration {
	let id = MigrationId(migration::SHAPE.get_u64(row, migration::ID));
	let name = migration::SHAPE.get_utf8(row, migration::NAME).to_string();
	let body = migration::SHAPE.get_utf8(row, migration::BODY).to_string();
	let rollback_body_str = migration::SHAPE.get_utf8(row, migration::ROLLBACK_BODY).to_string();
	let rollback_body = if rollback_body_str.is_empty() {
		None
	} else {
		Some(rollback_body_str)
	};

	Migration {
		id,
		name,
		body,
		rollback_body,
	}
}

fn decode_migration_event(row: &EncodedRow) -> MigrationEvent {
	let id = MigrationEventId(migration_event::SHAPE.get_u64(row, migration_event::ID));
	let migration_id = MigrationId(migration_event::SHAPE.get_u64(row, migration_event::MIGRATION_ID));
	let action_raw = migration_event::SHAPE.get_u8(row, migration_event::ACTION);
	let action = if action_raw == 0 {
		MigrationAction::Applied
	} else {
		MigrationAction::Rollback
	};

	MigrationEvent {
		id,
		migration_id,
		action,
	}
}