use rusqlite::{params, Connection, OptionalExtension};
use uqa_storage::{
mvcc::{CommitSequence, DatabaseId, VersionError},
read_control::StorageReadControl,
};
use super::{
capture, graph_lookup, invalid, owners, physical, NativeMapping, NativeRecord,
NativeRecordFamily as Family, NativeRecordNamespace,
};
use crate::mvcc::{codec, schema, write, PhysicalResult};
mod graph_lookup_upgrade;
mod occurrence_accelerators;
const LEGACY_FORMAT: &str = "CREATE TABLE _uqa_mvcc_native_format (singleton INTEGER PRIMARY KEY CHECK(singleton = 1), format INTEGER NOT NULL CHECK(format = 1), catalog_version INTEGER NOT NULL CHECK(catalog_version = 49))";
const FORMAT_TWO: &str = "CREATE TABLE _uqa_mvcc_native_format (singleton INTEGER PRIMARY KEY CHECK(singleton = 1), format INTEGER NOT NULL CHECK(format = 2), catalog_version INTEGER NOT NULL CHECK(catalog_version = 49))";
const FORMAT_THREE: &str = "CREATE TABLE _uqa_mvcc_native_format (singleton INTEGER PRIMARY KEY CHECK(singleton = 1), format INTEGER NOT NULL CHECK(format = 3), catalog_version INTEGER NOT NULL CHECK(catalog_version = 49))";
const FORMAT_FOUR: &str = "CREATE TABLE _uqa_mvcc_native_format (singleton INTEGER PRIMARY KEY CHECK(singleton = 1), format INTEGER NOT NULL CHECK(format = 4), catalog_version INTEGER NOT NULL CHECK(catalog_version = 49))";
const FORMAT_FIVE: &str = "CREATE TABLE _uqa_mvcc_native_format (singleton INTEGER PRIMARY KEY CHECK(singleton = 1), format INTEGER NOT NULL CHECK(format = 5), catalog_version INTEGER NOT NULL CHECK(catalog_version = 49))";
const FORMAT_SIX: &str = "CREATE TABLE _uqa_mvcc_native_format (singleton INTEGER PRIMARY KEY CHECK(singleton = 1), format INTEGER NOT NULL CHECK(format = 6), catalog_version INTEGER NOT NULL CHECK(catalog_version = 49))";
const FORMAT_SEVEN: &str = "CREATE TABLE _uqa_mvcc_native_format (singleton INTEGER PRIMARY KEY CHECK(singleton = 1), format INTEGER NOT NULL CHECK(format = 7), catalog_version INTEGER NOT NULL CHECK(catalog_version = 49))";
const FORMAT_EIGHT: &str = "CREATE TABLE _uqa_mvcc_native_format (singleton INTEGER PRIMARY KEY CHECK(singleton = 1), format INTEGER NOT NULL CHECK(format = 8), catalog_version INTEGER NOT NULL CHECK(catalog_version = 49))";
const FORMAT_NINE: &str = "CREATE TABLE _uqa_mvcc_native_format (singleton INTEGER PRIMARY KEY CHECK(singleton = 1), format INTEGER NOT NULL CHECK(format = 9), catalog_version INTEGER NOT NULL CHECK(catalog_version = 49), record_namespace BLOB NOT NULL CHECK(typeof(record_namespace) = 'blob' AND length(record_namespace) = 16))";
const FORMAT_TEN: &str = "CREATE TABLE _uqa_mvcc_native_format (singleton INTEGER PRIMARY KEY CHECK(singleton = 1), format INTEGER NOT NULL CHECK(format = 10), catalog_version INTEGER NOT NULL CHECK(catalog_version = 49), record_namespace BLOB NOT NULL CHECK(typeof(record_namespace) = 'blob' AND length(record_namespace) = 16))";
const FORMAT_ELEVEN: &str = "CREATE TABLE _uqa_mvcc_native_format (singleton INTEGER PRIMARY KEY CHECK(singleton = 1), format INTEGER NOT NULL CHECK(format = 11), catalog_version INTEGER NOT NULL CHECK(catalog_version = 49), record_namespace BLOB NOT NULL CHECK(typeof(record_namespace) = 'blob' AND length(record_namespace) = 16))";
const FORMAT_TWELVE: &str = "CREATE TABLE _uqa_mvcc_native_format (singleton INTEGER PRIMARY KEY CHECK(singleton = 1), format INTEGER NOT NULL CHECK(format = 12), catalog_version INTEGER NOT NULL CHECK(catalog_version = 49), record_namespace BLOB NOT NULL CHECK(typeof(record_namespace) = 'blob' AND length(record_namespace) = 16))";
const FORMAT_THIRTEEN: &str = "CREATE TABLE _uqa_mvcc_native_format (singleton INTEGER PRIMARY KEY CHECK(singleton = 1), format INTEGER NOT NULL CHECK(format = 13), catalog_version INTEGER NOT NULL CHECK(catalog_version = 49), record_namespace BLOB NOT NULL CHECK(typeof(record_namespace) = 'blob' AND length(record_namespace) = 16))";
const FORMAT_FOURTEEN: &str = "CREATE TABLE _uqa_mvcc_native_format (singleton INTEGER PRIMARY KEY CHECK(singleton = 1), format INTEGER NOT NULL CHECK(format = 14), catalog_version INTEGER NOT NULL CHECK(catalog_version = 49), record_namespace BLOB NOT NULL CHECK(typeof(record_namespace) = 'blob' AND length(record_namespace) = 16))";
pub(super) const CURRENT_VERSION: u32 = 15;
const FOREIGN_SERVER_METADATA_VERSION: u32 = 15;
const SEQUENCE_VALUES_VERSION: u32 = 14;
#[cfg(test)]
mod tests;
const TABLES: [(&str, &str); 4] = [
("_uqa_mvcc_native_format", "CREATE TABLE _uqa_mvcc_native_format (singleton INTEGER PRIMARY KEY CHECK(singleton = 1), format INTEGER NOT NULL CHECK(format = 15), catalog_version INTEGER NOT NULL CHECK(catalog_version = 49), record_namespace BLOB NOT NULL CHECK(typeof(record_namespace) = 'blob' AND length(record_namespace) = 16))"),
("_uqa_mvcc_native_owners", "CREATE TABLE _uqa_mvcc_native_owners (name TEXT PRIMARY KEY NOT NULL, object_id BLOB NOT NULL CHECK(typeof(object_id) = 'blob' AND length(object_id) = 16 AND object_id != zeroblob(16)), generation BLOB NOT NULL CHECK(typeof(generation) = 'blob' AND length(generation) = 16 AND generation != zeroblob(16)), catalog_owned INTEGER NOT NULL CHECK(catalog_owned IN (0, 1))) WITHOUT ROWID"),
("_uqa_mvcc_native_expected", "CREATE TABLE _uqa_mvcc_native_expected (family INTEGER NOT NULL, physical_key BLOB NOT NULL, old_key BLOB, new_key BLOB, new_value BLOB, PRIMARY KEY(family, physical_key), CHECK((new_key IS NULL) = (new_value IS NULL))) WITHOUT ROWID"),
("_uqa_mvcc_native_changes", "CREATE TABLE _uqa_mvcc_native_changes (family INTEGER NOT NULL, physical_key BLOB NOT NULL, PRIMARY KEY(family, physical_key)) WITHOUT ROWID"),
];
const OWNER_INDEX: &str =
"CREATE UNIQUE INDEX _uqa_mvcc_native_owner_identity ON _uqa_mvcc_native_owners(object_id)";
const DISKANN_TABLES: [(u32, Family, &str); 5] = [
(10, Family::DiskANNRecords, super::diskann::SQL),
(11, Family::VectorOrigins, super::diskann::ORIGINS_SQL),
(12, Family::VectorChanges, super::diskann::CHANGES_SQL),
(
13,
super::populations::schema::TABLES[0].0,
super::populations::schema::TABLES[0].1,
),
(
13,
super::populations::schema::TABLES[1].0,
super::populations::schema::TABLES[1].1,
),
];
pub(in crate::mvcc) fn present(connection: &Connection) -> PhysicalResult<bool> {
Ok(connection.query_row(
"SELECT EXISTS(SELECT 1 FROM sqlite_schema WHERE name GLOB '_uqa_mvcc_native_*')",
[],
|row| row.get(0),
)?)
}
pub(in crate::mvcc) fn reject_mapped(connection: &Connection) -> PhysicalResult<()> {
if present(connection)? {
return Err(
invalid("native records require their materializing persistence adapter").into(),
);
}
Ok(())
}
pub(in crate::mvcc) fn check_mapping(
connection: &Connection,
native: Option<NativeRecordNamespace>,
) -> PhysicalResult<()> {
let Some(expected) = native else {
return reject_mapped(connection);
};
check_mapping_version(connection, CURRENT_VERSION)?;
if namespace(connection)? != expected {
return Err(invalid("native record namespace changed").into());
}
Ok(())
}
fn namespace(connection: &Connection) -> PhysicalResult<NativeRecordNamespace> {
let mut statement = connection.prepare_cached(
"SELECT record_namespace FROM _uqa_mvcc_native_format WHERE singleton = 1",
)?;
let mut rows = statement.query([])?;
let row = rows
.next()?
.ok_or_else(|| invalid("missing native record namespace"))?;
Ok(NativeRecordNamespace(codec::identity(codec::bytes(
row, 0,
)?)?))
}
pub(in crate::mvcc) fn validate_restoration(connection: &Connection) -> PhysicalResult<()> {
validate_format(connection, CURRENT_VERSION)?;
check_mapping_version(connection, CURRENT_VERSION)?;
namespace(connection)?;
Ok(())
}
fn insert_format(connection: &Connection, namespace: DatabaseId) -> PhysicalResult<()> {
connection.execute(
"INSERT INTO _uqa_mvcc_native_format VALUES (1, ?1, 49, ?2)",
params![CURRENT_VERSION, namespace.as_bytes().as_slice()],
)?;
Ok(())
}
fn check_mapping_version(connection: &Connection, version: u32) -> PhysicalResult<()> {
let valid: bool = connection.prepare_cached("SELECT (SELECT count(*) = 1 FROM _uqa_mvcc_native_format WHERE singleton = 1 AND format = ?1 AND catalog_version = 49) AND (SELECT value = '49' FROM _metadata WHERE key = 'schema_version') AND NOT EXISTS(SELECT 1 FROM _uqa_mvcc_native_expected) AND NOT EXISTS(SELECT 1 FROM _uqa_mvcc_native_changes)")?.query_row([version], |row| row.get(0))?;
if !valid {
return Err(
invalid("incomplete native record format or unfinished materialization").into(),
);
}
Ok(())
}
fn prepare_catalog_sources(
connection: &Connection,
control: &StorageReadControl,
) -> PhysicalResult<()> {
crate::Catalog::promote_legacy_graph_catalog(connection)?;
super::standalone_graph::import_sources(connection, control)?;
crate::Catalog::migrate_storage_in(connection)?;
crate::Catalog::prepare_native_fts_sources(connection)?;
let source: Option<bool> = connection
.query_row(
"SELECT value = ?1 FROM _metadata WHERE key = 'schema_version'",
[crate::catalog::CURRENT_SCHEMA_VERSION.to_string()],
|row| row.get(0),
)
.optional()?;
if source != Some(true) {
return Err(
invalid("native mapping requires the current initialized physical catalog").into(),
);
}
Ok(())
}
pub(in crate::mvcc) fn initialize(
connection: &Connection,
control: &StorageReadControl,
) -> PhysicalResult<NativeMapping> {
control.cancellation().check().map_err(VersionError::from)?;
let _permit = crate::mvcc::admission::permit(connection, control)?;
let transaction = crate::mvcc::admission::begin(connection, control)?;
let mapping = initialize_in(&transaction, control)?;
crate::mvcc::admission::commit(transaction, control)?;
Ok(mapping)
}
pub(in crate::mvcc) fn initialize_in(
transaction: &Connection,
control: &StorageReadControl,
) -> PhysicalResult<NativeMapping> {
control.cancellation().check().map_err(VersionError::from)?;
if transaction.is_autocommit() {
return Err(invalid("native baseline import requires an owning transaction").into());
}
if present(transaction)? {
let mapping = reopen(transaction, control, false)?;
control.cancellation().check().map_err(VersionError::from)?;
return Ok(mapping);
}
prepare_catalog_sources(transaction, control)?;
let identity = schema::initialize_in(transaction)?.identity;
let header = codec::header(transaction, identity)?;
let populated: bool = transaction.query_row("SELECT EXISTS(SELECT 1 FROM _uqa_mvcc_heads) OR EXISTS(SELECT 1 FROM _uqa_mvcc_versions) OR EXISTS(SELECT 1 FROM _uqa_mvcc_transactions) OR EXISTS(SELECT 1 FROM _uqa_mvcc_runs)", [], |row| row.get(0))?;
if header.key_value_mapping
|| header.allocated != 0
|| header.sequence.as_u64() != 0
|| populated
{
return Err(
invalid("cannot merge native catalog rows into an existing record history").into(),
);
}
for table in [
"_uqa_mvcc_metadata",
"_uqa_mvcc_heads",
"_uqa_mvcc_runs",
"_uqa_mvcc_versions",
"_uqa_mvcc_version_metadata",
"_uqa_mvcc_transactions",
"_uqa_mvcc_identifiers",
] {
for action in ["INSERT", "UPDATE", "DELETE"] {
transaction.execute_batch(&format!(
"DROP TRIGGER IF EXISTS uqa_cache_{table}_{action}"
))?;
}
}
create_provider_tables(transaction)?;
occurrence_accelerators::create(transaction)?;
occurrence_accelerators::import(transaction, control)?;
crate::Catalog::upgrade_metadata_cache_triggers(transaction)?;
validate_layouts(transaction, CURRENT_VERSION)?;
validate_cache_triggers(transaction, CURRENT_VERSION)?;
owners::seed(transaction, control)?;
super::sequences::validate_source(transaction)?;
super::sequence_values::seed(transaction)?;
graph_lookup::seed(transaction, control)?;
transaction.execute(
"UPDATE _metadata SET value = '49' WHERE key = 'schema_version'",
[],
)?;
let baseline = CommitSequence::from_u64(1);
for family in Family::all() {
physical::visit(transaction, family.layout(), control, |values| {
let owner = owners::for_row(transaction, identity, family, values, control)?;
let record = NativeRecord::encode(family, owner, values, control)?;
owners::validate(
transaction,
identity,
super::NativeRecordIdentity::new(family, owner)?,
values,
control,
)?;
write::stage_record(
transaction,
record.key(),
Some(record.row()),
baseline,
control,
)
})?;
}
transaction.execute(
"UPDATE _uqa_mvcc_metadata SET sequence = ?1 WHERE singleton = 1",
params![baseline.as_u64().to_be_bytes().as_slice()],
)?;
insert_format(transaction, identity)?;
install_guards(transaction)?;
super::standalone_graph::install_legacy_guards(transaction, control)?;
let invalid_foreign_key = transaction
.prepare("PRAGMA foreign_key_check")?
.query([])?
.next()?
.is_some();
if invalid_foreign_key {
return Err(invalid("native source catalog violates a physical foreign key").into());
}
control.cancellation().check().map_err(VersionError::from)?;
Ok(NativeMapping {
identity,
namespace: NativeRecordNamespace(identity),
})
}
fn create_provider_tables(transaction: &Connection) -> PhysicalResult<()> {
for (_, sql) in TABLES {
transaction.execute_batch(sql)?;
}
transaction.execute_batch(OWNER_INDEX)?;
transaction.execute_batch(graph_lookup::SQL)?;
transaction.execute_batch(super::occurrence_guards::SQL)?;
transaction.execute_batch(super::vector_guards::SQL)?;
for (_, _, sql) in DISKANN_TABLES {
transaction.execute_batch(sql)?;
}
transaction.execute_batch(super::sequence_values::SQL)?;
Ok(())
}
pub(in crate::mvcc) fn initialize_restoration(
connection: &Connection,
control: &StorageReadControl,
) -> PhysicalResult<NativeMapping> {
control.cancellation().check().map_err(VersionError::from)?;
if connection.is_autocommit() || !present(connection)? {
return Err(invalid(
"native restoration requires an existing mapping and owning transaction",
)
.into());
}
let mapping = reopen(connection, control, true)?;
control.cancellation().check().map_err(VersionError::from)?;
Ok(mapping)
}
fn stored_version(connection: &Connection) -> PhysicalResult<u32> {
for (version, definition) in (1_u32..).zip([
LEGACY_FORMAT,
FORMAT_TWO,
FORMAT_THREE,
FORMAT_FOUR,
FORMAT_FIVE,
FORMAT_SIX,
FORMAT_SEVEN,
FORMAT_EIGHT,
FORMAT_NINE,
FORMAT_TEN,
FORMAT_ELEVEN,
FORMAT_TWELVE,
FORMAT_THIRTEEN,
FORMAT_FOURTEEN,
]) {
if schema::definition_matches(connection, TABLES[0].0, definition)? == Some(true) {
return Ok(version);
}
}
Ok(CURRENT_VERSION)
}
fn record_history(connection: &Connection, restoring: bool) -> PhysicalResult<DatabaseId> {
if restoring {
schema::initialize_restoration(connection)?;
let (identity, header, pending) = codec::restoration_header(connection)?;
if pending.is_none() || header.key_value_mapping {
return Err(invalid("native restoration requires a pending native history").into());
}
return Ok(identity);
}
let initialized = schema::initialize_in(connection)?;
if initialized.created {
return Err(invalid("native mapping has no record history format").into());
}
if codec::header(connection, initialized.identity)?.key_value_mapping {
return Err(invalid("mixed native and KeyValue mappings").into());
}
Ok(initialized.identity)
}
fn reopen(
connection: &Connection,
control: &StorageReadControl,
restoring: bool,
) -> PhysicalResult<NativeMapping> {
crate::Catalog::upgrade_metadata_cache_triggers(connection)?;
let version = stored_version(connection)?;
validate_format(connection, version)?;
let identity = record_history(connection, restoring)?;
check_mapping_version(connection, version)?;
if version < 8
&& connection.query_row("SELECT EXISTS(SELECT 1 FROM _uqa_mvcc_runs)", [], |row| {
row.get::<_, bool>(0)
})?
{
return Err(invalid("predecessor native mapping contains current record runs").into());
}
super::sequences::validate_source(connection)?;
if version < 3 {
graph_lookup_upgrade::upgrade(connection, identity, version, control)?;
}
if version < 4 {
occurrence_accelerators::create(connection)?;
for family in [Family::OccurrenceSkips, Family::OccurrenceBlockMax] {
install_family_guards(connection, family)?;
}
}
if version < 5 {
connection.execute_batch(super::occurrence_guards::SQL)?;
install_family_guards(connection, Family::OccurrenceGuards)?;
}
if version < 6 {
connection.execute_batch(super::vector_guards::SQL)?;
install_family_guards(connection, Family::VectorGuards)?;
crate::Catalog::upgrade_metadata_cache_triggers(connection)?;
}
if version < 8 {
super::standalone_graph::create(connection)?;
for &(family, _) in super::standalone_graph::schema::TABLES {
install_family_guards(connection, family)?;
}
for (_, sql) in graph_lookup::source_triggers(&graph_lookup::SCOPED_SOURCES) {
connection.execute_batch(&sql)?;
}
}
for (minimum, family, sql) in DISKANN_TABLES {
if version < minimum {
connection.execute_batch(sql)?;
install_family_guards(connection, family)?;
}
}
if version < SEQUENCE_VALUES_VERSION {
connection.execute_batch(super::sequence_values::SQL)?;
super::sequence_values::backfill(connection, identity, control)?;
install_family_guards(connection, Family::SequenceValues)?;
}
if version < FOREIGN_SERVER_METADATA_VERSION {
connection.execute_batch(super::foreign_servers::SQL)?;
for action in ["INSERT", "UPDATE", "DELETE"] {
let (_, sql) = crate::Catalog::cache_revision_trigger(
Family::ForeignServerMetadata.layout().table,
false,
action,
);
connection.execute_batch(&sql)?;
}
install_family_guards(connection, Family::ForeignServerMetadata)?;
}
if version < CURRENT_VERSION {
upgrade_format(connection, version, identity)?;
}
super::standalone_graph::validate_legacy_guards(connection, control)?;
Ok(NativeMapping {
identity,
namespace: namespace(connection)?,
})
}
fn upgrade_format(
connection: &Connection,
version: u32,
identity: DatabaseId,
) -> PhysicalResult<()> {
let data_namespace = if version >= 9 {
namespace(connection)?.0
} else {
identity
};
connection.execute_batch("DROP TABLE _uqa_mvcc_native_format")?;
connection.execute_batch(TABLES[0].1)?;
insert_format(connection, data_namespace)?;
for action in ["INSERT", "UPDATE", "DELETE"] {
connection.execute_batch(&schema::trigger(TABLES[0].0, action).1)?;
}
validate_format(connection, CURRENT_VERSION)?;
check_mapping_version(connection, CURRENT_VERSION)
}
fn install_guards(transaction: &Connection) -> PhysicalResult<()> {
for (name, _) in TABLES {
for action in ["INSERT", "UPDATE", "DELETE"] {
transaction.execute_batch(&schema::trigger(name, action).1)?;
}
}
for family in Family::all() {
install_family_guards(transaction, family)?;
}
for (_, sql) in graph_lookup::triggers() {
transaction.execute_batch(&sql)?;
}
Ok(())
}
fn install_family_guards(transaction: &Connection, family: Family) -> PhysicalResult<()> {
for action in ["INSERT", "UPDATE", "DELETE"] {
if family != Family::TableOwners {
transaction.execute_batch(&schema::trigger(family.layout().table, action).1)?;
}
transaction.execute_batch(&capture::trigger(family, action).1)?;
}
Ok(())
}
fn validate_format(connection: &Connection, version: u32) -> PhysicalResult<()> {
let legacy = version == 1;
for (name, sql) in TABLES {
let sql = if name == TABLES[0].0 {
match version {
1 => LEGACY_FORMAT,
2 => FORMAT_TWO,
3 => FORMAT_THREE,
4 => FORMAT_FOUR,
5 => FORMAT_FIVE,
6 => FORMAT_SIX,
7 => FORMAT_SEVEN,
8 => FORMAT_EIGHT,
9 => FORMAT_NINE,
10 => FORMAT_TEN,
11 => FORMAT_ELEVEN,
12 => FORMAT_TWELVE,
13 => FORMAT_THIRTEEN,
14 => FORMAT_FOURTEEN,
_ => sql,
}
} else {
sql
};
require_definition(connection, name, sql)?;
for action in ["INSERT", "UPDATE", "DELETE"] {
let (name, sql) = schema::trigger(name, action);
require_definition(connection, &name, &sql)?;
}
}
require_definition(connection, "_uqa_mvcc_native_owner_identity", OWNER_INDEX)?;
if version >= 4 {
for (family, sql) in occurrence_accelerators::TABLES {
require_definition(connection, family.layout().table, sql)?;
}
}
if version >= 5 {
require_definition(
connection,
Family::OccurrenceGuards.layout().table,
super::occurrence_guards::SQL,
)?;
}
if version >= 6 {
require_definition(
connection,
Family::VectorGuards.layout().table,
super::vector_guards::SQL,
)?;
}
if version >= 8 {
for &(family, sql) in super::standalone_graph::schema::TABLES {
require_definition(connection, family.layout().table, sql)?;
}
for (name, sql) in graph_lookup::source_triggers(&graph_lookup::SCOPED_SOURCES) {
require_definition(connection, &name, &sql)?;
}
}
for (minimum, family, sql) in DISKANN_TABLES {
if version >= minimum {
require_definition(connection, family.layout().table, sql)?;
}
}
if version >= SEQUENCE_VALUES_VERSION {
require_definition(
connection,
Family::SequenceValues.layout().table,
super::sequence_values::SQL,
)?;
}
validate_foreign_server_metadata(connection, version)?;
for family in families(version) {
for action in ["INSERT", "UPDATE", "DELETE"] {
let (name, sql) = schema::trigger(family.layout().table, action);
require_definition(connection, &name, &sql)?;
let (name, sql) = capture::trigger(family, action);
require_definition(connection, &name, &sql)?;
}
}
validate_cache_triggers(connection, version)?;
if !legacy {
require_definition(
connection,
Family::GraphLookups.layout().table,
graph_lookup::SQL,
)?;
let sources = if version == 2 {
&graph_lookup::SOURCES[..3]
} else {
&graph_lookup::SOURCES[..]
};
for (name, sql) in graph_lookup::source_triggers(sources) {
require_definition(connection, &name, &sql)?;
}
}
validate_layouts(connection, version)
}
fn validate_foreign_server_metadata(connection: &Connection, version: u32) -> PhysicalResult<()> {
if version >= FOREIGN_SERVER_METADATA_VERSION {
require_definition(
connection,
Family::ForeignServerMetadata.layout().table,
super::foreign_servers::SQL,
)?;
}
Ok(())
}
fn require_definition(connection: &Connection, name: &str, sql: &str) -> PhysicalResult<()> {
if schema::definition_matches(connection, name, sql)? != Some(true) {
return Err(invalid("missing or changed native materialization schema or guard").into());
}
Ok(())
}
fn validate_cache_triggers(connection: &Connection, version: u32) -> PhysicalResult<()> {
for family in families(version).filter(|family| {
!family.is_standalone_graph()
&& !matches!(
family,
Family::CacheRevisions
| Family::TableOwners
| Family::OccurrenceGuards
| Family::VectorGuards
| Family::GraphLookups
| Family::GraphPathPairs
| Family::GraphPathIndexState
| Family::DiskANNRecords
| Family::VectorOrigins
| Family::VectorChanges
| Family::VectorPopulations
| Family::VectorPopulationWitnesses
| Family::SequenceValues
)
}) {
let layout = family.layout();
for event in ["INSERT", "DELETE", "UPDATE"] {
let (name, sql) = crate::Catalog::cache_revision_trigger(
layout.table,
layout.columns.contains(&"table_name"),
event,
);
require_definition(connection, &name, &sql)?;
}
}
Ok(())
}
fn families(version: u32) -> impl Iterator<Item = Family> {
Family::all().filter(move |family| match family {
family if family.is_standalone_graph() => version >= 8,
Family::GraphLookups => version >= 2,
Family::OccurrenceSkips | Family::OccurrenceBlockMax => version >= 4,
Family::OccurrenceGuards => version >= 5,
Family::VectorGuards => version >= 6,
Family::DiskANNRecords => version >= 10,
Family::VectorOrigins => version >= 11,
Family::VectorChanges => version >= 12,
Family::VectorPopulations | Family::VectorPopulationWitnesses => version >= 13,
Family::SequenceValues => version >= SEQUENCE_VALUES_VERSION,
Family::ForeignServerMetadata => version >= FOREIGN_SERVER_METADATA_VERSION,
_ => true,
})
}
fn validate_layouts(connection: &Connection, version: u32) -> PhysicalResult<()> {
for family in families(version) {
let layout = family.layout();
let mut statement = connection.prepare(&format!("PRAGMA table_info({})", layout.table))?;
let mut rows = statement.query([])?;
let mut count = 0;
while let Some(row) = rows.next()? {
if count >= layout.columns.len() {
return Err(invalid("unexpected native materialization column").into());
}
let name = row
.get_ref(1)?
.as_str()
.map_err(|_| invalid("native column name is not UTF-8"))?;
let kind = row
.get_ref(2)?
.as_str()
.map_err(|_| invalid("native column type is not UTF-8"))?;
let not_null: bool = row.get(3)?;
let primary = usize::from(row.get::<_, u16>(5)?);
let expected_key = layout
.primary_key
.iter()
.position(|&column| column == count)
.map_or(0, |slot| slot + 1);
if name != layout.columns[count]
|| kind != layout.column_types[count].declaration()
|| not_null == layout.nullable[count]
|| primary != expected_key
{
return Err(invalid(
"native materialization columns do not match the record layout",
)
.into());
}
count += 1;
}
if count != layout.columns.len() {
return Err(invalid("missing native materialization columns").into());
}
}
let mut statement = connection.prepare(
"SELECT name FROM sqlite_schema WHERE type = 'table' AND name NOT GLOB 'sqlite_*'",
)?;
let mut rows = statement.query([])?;
while let Some(row) = rows.next()? {
let name = row
.get_ref(0)?
.as_str()
.map_err(|_| invalid("native table name is not UTF-8"))?;
if !families(version).any(|family| family.layout().table == name)
&& !TABLES.iter().any(|(table, _)| *table == name)
&& !matches!(
name,
"_uqa_mvcc_metadata"
| "_uqa_mvcc_heads"
| "_uqa_mvcc_runs"
| "_uqa_mvcc_versions"
| "_uqa_mvcc_version_metadata"
| "_uqa_mvcc_transactions"
| "_uqa_mvcc_identifiers"
)
{
return Err(invalid("unmapped native table requires an explicit record family").into());
}
}
Ok(())
}