use crate::ObjectKind;
use crate::core::failed;
use crate::event::Event;
use crate::failure::FailureCode;
use crate::ids::TabId;
use crate::port::{DriverCapabilities, PortError, SchemaChange};
use crate::schema::TableDef;
use crate::state::DatabaseState;
mod alter;
mod import;
mod password;
mod rows;
mod sidecar;
mod template;
use sidecar::read_sidecar;
impl crate::core::Core {
pub(crate) fn open_database(
&mut self,
path: std::path::PathBuf,
password: Option<String>,
) -> Vec<Event> {
if self.state.database.is_some() {
return failed(
FailureCode::Lifecycle,
"a database is already open — close it first",
);
}
match self.port.open(&path, password.as_deref()) {
Err(PortError::PasswordRequired { .. }) => {
vec![Event::PasswordRequired { path }]
}
Err(PortError::WrongPassword { .. }) => {
vec![Event::PasswordRejected { path }]
}
Err(e) => failed(FailureCode::Port, e.to_string()),
Ok(opened) => {
let name = opened.name.clone();
let format = opened.format;
let lock_file = opened.lock_file.clone();
let driver = self.port.driver_id();
let capabilities = self.port.capabilities();
let relationships = self.port.relationships().unwrap_or_default();
let (macros, macros_error) = match self.port.macros() {
Ok(macros) => (macros, None),
Err(error) => (Vec::new(), Some(error.to_string())),
};
let (vba_project, vba_error) = match self.port.vba_project() {
Ok(project) => (project, None),
Err(error) => (None, Some(error.to_string())),
};
let (native_queries, native_queries_error) = match self.port.native_queries() {
Ok(queries) => (queries, None),
Err(error) => (Vec::new(), Some(error.to_string())),
};
let (sidecar, sidecar_error) = match read_sidecar(&path, &name) {
Ok(Some(document)) => (Some(document), None),
Ok(None) => (None, None),
Err(reason) => (None, Some(reason)),
};
let mut tables = self.port.tables();
let mut sidecar_error = sidecar_error;
if let Some(document) = &sidecar {
let mut merged = tables.clone();
match document.apply_table_properties(&mut merged) {
Ok(()) => tables = merged,
Err(error) => sidecar_error = Some(error.to_string()),
}
}
let sidecar_path = path.with_extension("datacraft");
self.state.sql_result = None;
self.state.expression_result = None;
self.state.pending_write = None;
self.state.last_applied = None;
self.state.database = Some(DatabaseState {
table_views: std::collections::BTreeMap::new(),
path,
name: name.clone(),
format,
driver: driver.clone(),
capabilities,
tables,
relationships,
queries: sidecar
.as_ref()
.map(|document| document.queries.clone())
.unwrap_or_default(),
forms: sidecar
.as_ref()
.map(|document| document.forms.clone())
.unwrap_or_default(),
reports: sidecar
.as_ref()
.map(|document| document.reports.clone())
.unwrap_or_default(),
native_queries,
native_queries_error,
macros,
macros_error,
vba_project,
vba_error,
sidecar_error,
lock_file,
undo: Vec::new(),
redo: Vec::new(),
});
let mut events = vec![Event::DatabaseOpened { name, format }];
if let Some(document) = sidecar {
events.push(Event::DesignDocumentLoaded {
path: sidecar_path,
forms: document.forms.len(),
queries: document.queries.len(),
reports: document.reports.len(),
});
}
events
}
}
}
pub(crate) fn close_database(&mut self) -> Vec<Event> {
if self.state.database.is_none() {
return failed(FailureCode::NoDatabase, "no database is open");
}
let mut events: Vec<Event> = self
.state
.tabs
.drain(..)
.map(|tab| Event::TabClosed { tab_id: tab.id })
.collect();
self.state.active_tab = None;
self.state.database = None;
self.state.relationship_mapper_open = false;
self.state.sql_window_open = false;
self.state.sql_result = None;
self.state.expression_result = None;
self.state.pending_write = None;
self.state.last_applied = None;
self.port.close();
events.push(Event::DatabaseClosed);
events
}
pub(crate) fn create_database(
&mut self,
path: std::path::PathBuf,
format: crate::port::DatabaseFormat,
) -> Vec<Event> {
if !self.port.capabilities().create_database {
return failed(
FailureCode::Capability(crate::availability::DisabledReason::NoRelationships),
DriverCapabilities::unsupported(&self.port.driver_id(), "create database files"),
);
}
match self.port.create_database(&path, format) {
Ok(()) => vec![Event::DatabaseCreated { path, format }],
Err(e) => failed(FailureCode::Port, e.to_string()),
}
}
pub(crate) fn create_table(&mut self, definition: TableDef) -> Vec<Event> {
let Some(db) = self.state.database.as_mut() else {
return failed(
FailureCode::NoDatabase,
"no database is open — open a database first",
);
};
if !db.capabilities.create_table {
return failed(
FailureCode::Capability(crate::availability::DisabledReason::CreateTables),
DriverCapabilities::unsupported(&db.driver, "create tables for this source"),
);
}
if let Err(e) = definition.validate() {
return failed(FailureCode::Port, e.to_string());
}
if db
.tables
.iter()
.any(|t| t.name.to_lowercase() == definition.name.to_lowercase())
{
return failed(
FailureCode::Duplicate,
format!("duplicate table name {:?}", definition.name),
);
}
match self.port.create_table(&definition) {
Err(e) => failed(FailureCode::Port, e.to_string()),
Ok(()) => {
let name = definition.name.clone();
db.tables.push(definition);
vec![Event::TableCreated { table: name }]
}
}
}
pub(crate) fn drop_table(&mut self, table: &str) -> Vec<Event> {
let Some(db) = self.state.database.as_ref() else {
return failed(
FailureCode::NoDatabase,
"no database is open — open a database first",
);
};
if !db.capabilities.drop_table {
return failed(
FailureCode::Capability(crate::availability::DisabledReason::DropTables),
DriverCapabilities::unsupported(&db.driver, "drop tables for this source"),
);
}
let canonical = match self.port.drop_table(table) {
Err(e) => return failed(FailureCode::Port, e.to_string()),
Ok(canonical) => canonical,
};
if let Some(db) = self.state.database.as_mut() {
db.table_views.remove(&canonical);
}
let dependent: Vec<TabId> = self
.state
.tabs
.iter()
.filter(|tab| {
tab.object.kind == ObjectKind::Table
&& tab.object.name.to_lowercase() == canonical.to_lowercase()
})
.map(|tab| tab.id)
.collect();
let mut events: Vec<Event> = Vec::with_capacity(dependent.len() + 1);
for tab_id in dependent {
self.remove_tab(tab_id);
events.push(Event::TabClosed { tab_id });
}
if let Some(db) = self.state.database.as_mut() {
db.tables.retain(|t| t.name != canonical);
db.relationships.retain(|rel| {
!rel.table.eq_ignore_ascii_case(&canonical)
&& !rel.related_table.eq_ignore_ascii_case(&canonical)
});
}
events.push(Event::TableDropped { table: canonical });
events
}
pub(crate) fn alter_table(&mut self, table: &str, change: SchemaChange) -> Vec<Event> {
let Some(db) = self.state.database.as_ref() else {
return failed(
FailureCode::NoDatabase,
"no database is open — open a database first",
);
};
if !db.capabilities.alter_table {
return failed(
FailureCode::Capability(crate::availability::DisabledReason::AlterTables),
DriverCapabilities::unsupported(&db.driver, "alter the schema for this source"),
);
}
let Some(def) = db
.tables
.iter()
.find(|candidate| candidate.name.eq_ignore_ascii_case(table))
.cloned()
else {
return failed(
FailureCode::NotFound,
PortError::TableNotFound(table.to_owned()).to_string(),
);
};
let mut trial = def.clone();
let field = match alter::apply_schema_change(&mut trial, &change) {
Ok(field) => field,
Err(reason) => return failed(FailureCode::InvalidInput, reason),
};
if let Err(error) = trial.validate() {
return failed(
FailureCode::InvalidInput,
format!("invalid schema change: {error}"),
);
}
let canonical = def.name.clone();
let old_tables = db.tables.clone();
if let Err(error) = self.port.alter_table(&canonical, change) {
return failed(FailureCode::Port, error.to_string());
}
let mut tables = self.port.tables();
crate::schema::SchemaDocument::merge_field_properties(&mut tables, &old_tables);
crate::schema::SchemaDocument::merge_field_properties(&mut tables, &[trial.clone()]);
if let Some(db) = self.state.database.as_mut() {
db.tables = tables;
}
vec![Event::TableAltered {
table: canonical,
field,
}]
}
}