reifydb-rql 0.4.12

ReifyDB Query Language (RQL) parser and AST
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

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

use reifydb_core::{
	error::diagnostic::catalog::table_not_found,
	interface::resolved::{
		ResolvedColumn, ResolvedNamespace, ResolvedSequence, ResolvedShape, ResolvedTable, Sequence,
	},
};
use reifydb_transaction::transaction::Transaction;
use reifydb_type::{fragment::Fragment, return_error};

use crate::{
	Result,
	nodes::AlterSequenceNode,
	plan::{
		logical::{self},
		physical::{Compiler, PhysicalPlan},
	},
};

impl<'bump> Compiler<'bump> {
	pub(crate) fn compile_alter_sequence(
		&mut self,
		rx: &mut Transaction<'_>,
		alter: logical::AlterSequenceNode<'_>,
	) -> Result<PhysicalPlan<'bump>> {
		// Get the namespace segments from the sequence identifier
		let ns_segments: Vec<&str> = alter.sequence.namespace.iter().map(|n| n.text()).collect();

		// Query the catalog for the actual namespace
		let namespace = self
			.catalog
			.find_namespace_by_segments(rx, &ns_segments)?
			.unwrap_or_else(|| panic!("Namespace '{}' not found", ns_segments.join("::")));

		// Query the catalog for the actual table
		let table_name = alter.sequence.name.text();
		let Some(table) = self.catalog.find_table_by_name(rx, namespace.id(), table_name)? else {
			return_error!(table_not_found(
				self.interner.intern_fragment(&alter.sequence.name),
				namespace.name(),
				table_name
			));
		};

		// Find the column in the table
		let column_name = alter.column.name.text();
		let column = table
			.columns
			.iter()
			.find(|c| c.name == column_name)
			.unwrap_or_else(|| panic!("Column '{}' not found in table '{}'", column_name, table_name))
			.clone();

		// Create resolved namespace
		let namespace_fragment = Fragment::internal(namespace.name().to_string());
		let resolved_namespace = ResolvedNamespace::new(namespace_fragment, namespace.clone());

		// Create resolved sequence (using table name as sequence name)
		let sequence_def = Sequence {
			name: table_name.to_string(),
			current_value: 1, // This is not used in ALTER SEQUENCE, just a placeholder
			increment: 1,
		};
		let resolved_sequence = ResolvedSequence::new(
			self.interner.intern_fragment(&alter.sequence.name),
			resolved_namespace.clone(),
			sequence_def,
		);

		// Create resolved table
		let table_fragment = Fragment::internal(table_name.to_string());
		let resolved_table = ResolvedTable::new(table_fragment, resolved_namespace, table);

		// Create resolved source and column
		let resolved_source = ResolvedShape::Table(resolved_table);
		let resolved_column =
			ResolvedColumn::new(self.interner.intern_fragment(&alter.column.name), resolved_source, column);

		Ok(PhysicalPlan::AlterSequence(AlterSequenceNode {
			sequence: resolved_sequence,
			column: resolved_column,
			value: alter.value,
		}))
	}
}