mod records;
mod values;
use super::{
optional_text, text, Catalog, Family, NativeRecordOwner, NativeSnapshot, Result, SQLiteError,
};
use crate::catalog::{
sequences_views::codec::{concrete_sequence_options, decode_native_sequence_row},
RelationIdentity, RelationKind, SequenceRow,
};
use rusqlite::types::ValueRef;
use uqa_storage::catalog::SequenceValuePosition;
use uqa_storage::KeyValueBatch;
fn owner_id(owner: NativeRecordOwner) -> ([u8; 16], [u8; 16]) {
let NativeRecordOwner::Object {
identity,
generation,
} = owner
else {
unreachable!("sequence definitions are object-owned")
};
(identity, generation)
}
impl Catalog {
pub(in crate::catalog) fn native_sequence_has_private_changes(
&self,
object_id: [u8; 16],
) -> Result<bool> {
Ok(self
.read_native(|snapshot| {
let prefix = crate::mvcc::native::NativeRecordIdentity::object_prefix(
Family::Sequences,
object_id,
&snapshot.control,
)?;
Ok(!snapshot
.view
.private_keys(&prefix, None, 1, &snapshot.control)?
.is_empty())
})?
.unwrap_or(false))
}
pub(in crate::catalog) fn native_sequence_value_has_private_changes(
&self,
object_id: [u8; 16],
definition_generation: [u8; 16],
) -> Result<bool> {
Ok(self
.read_native(|snapshot| {
let key = crate::mvcc::native::NativeRecordIdentity::new(
Family::SequenceValues,
NativeRecordOwner::Object {
identity: object_id,
generation: definition_generation,
},
)?
.encode_key(&[], &snapshot.control)?;
Ok(!snapshot
.view
.private_keys(&key, None, 1, &snapshot.control)?
.is_empty())
})?
.unwrap_or(false))
}
pub(in crate::catalog) fn write_native_sequence(
&self,
sequence: &SequenceRow,
replace: bool,
) -> Result<Option<bool>> {
self.conn.with_native_write(|snapshot, batch| {
let previous = snapshot.sequence_named(&sequence.relation)?;
if replace != previous.is_some() {
return Ok(false);
}
let (old_id, old_generation) = previous.map_or(([0; 16], [0; 16]), owner_id);
let identity = snapshot.allocate_identity(if sequence.object_id == [0; 16] {
old_id
} else {
sequence.object_id
})?;
let generation =
snapshot.allocate_identity(if sequence.definition_generation == [0; 16] {
old_generation
} else {
sequence.definition_generation
})?;
let owner = NativeRecordOwner::Object {
identity,
generation,
};
snapshot.check_sequence_identity(&sequence.relation, identity)?;
if !replace {
snapshot.claim_relation(batch, &sequence.relation, RelationKind::Sequence)?;
}
let mut sequence = std::borrow::Cow::Borrowed(sequence);
match previous {
Some(old) if old == owner => {
let stored = snapshot.read_row(Family::Sequences, old, &[], |row| {
Ok((
values::integer(row[5]),
values::integer(row[6]) != 0,
values::integer(row[20]),
))
})?;
if let Some((current, called, log_count)) = stored {
let kept = sequence.to_mut();
kept.current = current;
kept.called = called;
kept.log_count = log_count;
}
}
Some(old) => {
snapshot.delete_prefix(batch, Family::Sequences, old, &[])?;
snapshot.delete_prefix(batch, Family::SequenceValues, old, &[])?;
}
None => {}
}
snapshot.put_sequence(batch, &sequence, owner)?;
if previous != Some(owner) {
snapshot.put_sequence_value(
batch,
owner,
SequenceValuePosition {
current: sequence.current,
called: sequence.called,
log_count: sequence.log_count,
},
)?;
}
Ok(true)
})
}
pub(in crate::catalog) fn rename_native_sequence(
&self,
from: &RelationIdentity,
to: &RelationIdentity,
) -> Result<Option<bool>> {
self.conn.with_native_write(|snapshot, batch| {
let Some(owner) = snapshot.sequence_named(from)? else {
return Ok(false);
};
if from == to {
return Ok(true);
}
if snapshot.relation_kind(to)?.is_some() {
return Err(SQLiteError::StorageBackend(format!(
"relation `{}` already exists",
to.qualified_name()
)));
}
snapshot.claim_relation(batch, to, RelationKind::Sequence)?;
snapshot.read_row(Family::Sequences, owner, &[], |row| {
let mut renamed = records::row_values(row);
renamed[0] = text(&to.schema);
renamed[1] = text(&to.name);
snapshot.put_row(batch, Family::Sequences, owner, &renamed)
})?;
snapshot.release_relation(batch, from, RelationKind::Sequence)?;
Ok(true)
})
}
pub(in crate::catalog) fn drop_native_sequence(
&self,
relation: &RelationIdentity,
) -> Result<Option<bool>> {
self.conn.with_native_write(|snapshot, batch| {
let Some(owner) = snapshot.sequence_named(relation)? else {
return Ok(false);
};
snapshot.delete_prefix(batch, Family::Sequences, owner, &[])?;
snapshot.delete_prefix(batch, Family::SequenceValues, owner, &[])?;
snapshot.release_relation(batch, relation, RelationKind::Sequence)?;
Ok(true)
})
}
pub(in crate::catalog) fn load_native_sequences(&self) -> Result<Option<Vec<SequenceRow>>> {
self.read_native(|snapshot| {
let mut sequences = Vec::new();
snapshot.visit_rows(Family::Sequences, None, &[], |row| {
sequences.push(decode_native_sequence_row(row)?);
Ok(())
})?;
for sequence in &mut sequences {
let position = snapshot
.sequence_value(NativeRecordOwner::Object {
identity: sequence.object_id,
generation: sequence.definition_generation,
})?
.ok_or_else(|| {
SQLiteError::StorageBackend(format!(
"sequence `{}` has no value record",
sequence.relation.qualified_name()
))
})?;
sequence.current = position.current;
sequence.called = position.called;
sequence.log_count = position.log_count;
}
sequences.sort_unstable_by(|left, right| left.relation.cmp(&right.relation));
Ok(sequences)
})
}
}
impl NativeSnapshot {
pub(super) fn sequence_value(
&self,
owner: NativeRecordOwner,
) -> Result<Option<SequenceValuePosition>> {
self.read_row(Family::SequenceValues, owner, &[], |row| {
Ok(SequenceValuePosition {
current: values::integer(row[2]),
called: values::integer(row[3]) != 0,
log_count: values::integer(row[4]),
})
})
}
pub(super) fn put_sequence_value(
&self,
batch: &mut dyn KeyValueBatch,
owner: NativeRecordOwner,
position: SequenceValuePosition,
) -> Result<()> {
if position.log_count < 0 {
return Err(SQLiteError::StorageBackend(
"sequence log count cannot be negative".into(),
));
}
let (identity, generation) = owner_id(owner);
self.put_row(
batch,
Family::SequenceValues,
owner,
&[
ValueRef::Blob(&identity),
ValueRef::Blob(&generation),
ValueRef::Integer(position.current),
ValueRef::Integer(i64::from(position.called)),
ValueRef::Integer(position.log_count),
],
)
}
fn put_sequence(
&self,
batch: &mut dyn KeyValueBatch,
sequence: &SequenceRow,
owner: NativeRecordOwner,
) -> Result<()> {
if !matches!(sequence.persistence.as_str(), "p" | "u")
|| sequence.options.cache_size <= 0
|| sequence.log_count < 0
{
return Err(SQLiteError::StorageBackend(format!(
"invalid durable sequence `{}` persistence, cache size or log count",
sequence.relation.qualified_name()
)));
}
let (identity, generation) = owner_id(owner);
let options = concrete_sequence_options(sequence);
let (role_owner, acl) = crate::catalog::role_security::encode_sequence(&sequence.security)?;
let owner_table = sequence.owner.map(|owner| owner.table_object_id);
let owner_column = sequence.owner.map(|owner| owner.column_object_id);
self.put_row(
batch,
Family::Sequences,
owner,
&[
text(&sequence.relation.schema),
text(&sequence.relation.name),
text("sequence"),
ValueRef::Integer(sequence.start),
ValueRef::Integer(sequence.increment),
ValueRef::Integer(sequence.current),
ValueRef::Integer(i64::from(sequence.called)),
text(&sequence.persistence),
ValueRef::Blob(&identity),
text(&options.data_type),
ValueRef::Integer(options.min_value.expect("concrete bound")),
ValueRef::Integer(options.max_value.expect("concrete bound")),
ValueRef::Integer(i64::from(options.cycle)),
ValueRef::Integer(options.cache_size),
ValueRef::Blob(&generation),
owner_table
.as_ref()
.map_or(ValueRef::Null, |id| ValueRef::Blob(id)),
owner_column
.as_ref()
.map_or(ValueRef::Null, |id| ValueRef::Blob(id)),
optional_text(sequence.owner.map(|owner| owner.dependency.catalog_code())),
(&role_owner).into(),
optional_text(acl.as_deref()),
ValueRef::Integer(sequence.log_count),
],
)
}
}