refactor(workspace): split SQL and database driver crates

This commit is contained in:
t8y2 committed 2026-09-25 15:51:58 +08:00
1 parent b99c60aff6
commit e0da2d09d3
180 files changed
+1422 -538

No files matched your search

@@ -0,0 +1,434 @@
use std::collections::HashMap;
use std::fs;
use std::path::{Path, PathBuf};
use std::sync::RwLock;
use super::descriptor::{DialectCapabilityDescriptor, DialectKind};
use super::dialect_yaml::DialectYaml;
/// Singleton dialect registry that holds all loaded dialect descriptors.
/// Thread-safe via RwLock. Access via `DialectRegistry::global()`.
pub struct DialectRegistry {
descriptors: RwLock<HashMap<String, LoadedDialect>>,
plugin_dirs: RwLock<Vec<PathBuf>>,
}
#[derive(Debug, Clone)]
pub struct LoadedDialect {
pub dialect_name: String,
pub kind: DialectKind,
pub descriptor: DialectCapabilityDescriptor,
pub yaml: DialectYaml,
pub source_path: Option<PathBuf>,
pub loaded_at: String,
}
#[derive(Debug, Clone)]
pub struct LoadError {
pub path: PathBuf,
pub error: String,
}
impl DialectRegistry {
pub fn new() -> Self {
Self { descriptors: RwLock::new(HashMap::new()), plugin_dirs: RwLock::new(Vec::new()) }
}
pub fn global() -> &'static Self {
use std::sync::OnceLock;
static INSTANCE: OnceLock<DialectRegistry> = OnceLock::new();
INSTANCE.get_or_init(DialectRegistry::new)
}
pub fn add_plugin_dir(&self, dir: PathBuf) {
if let Ok(mut dirs) = self.plugin_dirs.write() {
if !dirs.contains(&dir) {
dirs.push(dir);
}
}
}
pub fn get(&self, name: &str) -> Option<LoadedDialect> {
self.descriptors.read().ok().and_then(|d| d.get(&name.to_ascii_lowercase()).cloned())
}
pub fn get_by_kind(&self, kind: DialectKind) -> Option<LoadedDialect> {
self.descriptors.read().ok().and_then(|d| d.values().find(|ld| ld.kind == kind).cloned())
}
/// Return all loaded dialects that map to the given kind.
/// Unlike `get_by_kind` (which returns only the first match), this is
/// order-independent and is used when a type's capabilities must be
/// resolved across an entire dialect family (e.g. PostgreSQL, HighGo,
/// KingBase all share `DialectKind::Postgres`).
pub fn get_all_by_kind(&self, kind: DialectKind) -> Vec<LoadedDialect> {
self.descriptors
.read()
.ok()
.map(|d| d.values().filter(|ld| ld.kind == kind).cloned().collect())
.unwrap_or_default()
}
pub fn get_descriptor(&self, name: &str) -> Option<DialectCapabilityDescriptor> {
self.get(name).map(|ld| ld.descriptor)
}
pub fn get_descriptor_for_db(
&self,
db_type: crate::models::connection::DatabaseType,
) -> Option<DialectCapabilityDescriptor> {
if let Some(dialect_name) = crate::database_manifest::dialect_name(&db_type) {
if let Some(loaded) = self.get(dialect_name) {
return Some(loaded.descriptor);
}
}
let kind = DialectKind::from_database_type(db_type);
let label = kind.label();
let db_name = db_type.as_str();
self.get(db_name).or_else(|| self.get(label)).map(|ld| ld.descriptor)
}
pub fn get_yaml(&self, name: &str) -> Option<DialectYaml> {
self.get(name).map(|ld| ld.yaml)
}
pub fn has(&self, name: &str) -> bool {
self.descriptors.read().ok().is_some_and(|d| d.contains_key(&name.to_ascii_lowercase()))
}
pub fn all_names(&self) -> Vec<String> {
self.descriptors.read().ok().map(|d| d.keys().cloned().collect()).unwrap_or_default()
}
pub fn all_descriptors(&self) -> Vec<DialectCapabilityDescriptor> {
self.descriptors.read().ok().map(|d| d.values().map(|ld| ld.descriptor).collect()).unwrap_or_default()
}
pub fn register(
&self,
name: &str,
kind: DialectKind,
descriptor: DialectCapabilityDescriptor,
yaml: DialectYaml,
source_path: Option<PathBuf>,
) {
if let Ok(mut d) = self.descriptors.write() {
d.insert(
name.to_ascii_lowercase(),
LoadedDialect {
dialect_name: name.to_string(),
kind,
descriptor,
yaml,
source_path,
loaded_at: chrono::Utc::now().to_rfc3339(),
},
);
}
}
pub fn register_yaml(&self, path: &Path, yaml: DialectYaml, descriptor: DialectCapabilityDescriptor) {
let kind = descriptor.dialect;
let name = yaml.dialect.name.clone();
self.register(&name, kind, descriptor, yaml, Some(path.to_path_buf()));
}
pub fn register_descriptor(&self, name: &str, descriptor: DialectCapabilityDescriptor, yaml: DialectYaml) {
let kind = descriptor.dialect;
self.register(name, kind, descriptor, yaml, None);
}
pub fn unregister(&self, name: &str) -> bool {
self.descriptors.write().ok().is_some_and(|mut d| d.remove(&name.to_ascii_lowercase()).is_some())
}
pub fn is_empty(&self) -> bool {
self.descriptors.read().ok().is_none_or(|d| d.is_empty())
}
pub fn len(&self) -> usize {
self.descriptors.read().ok().map_or(0, |d| d.len())
}
}
impl Default for DialectRegistry {
fn default() -> Self {
Self::new()
}
}
/// Register all core dialect YAML definitions embedded at compile time.
/// Called once at startup by `lazy_init()`.
pub fn register_core_dialects() {
use std::sync::Once;
static INIT: Once = Once::new();
INIT.call_once(|| {
let registry = DialectRegistry::global();
include!(concat!(env!("OUT_DIR"), "/core_dialects.rs"));
let n = registry.len();
log::info!("Registered {n} core dialects");
});
}
// ============================================================================
// DialectPluginLoader — scans plugin directories and loads YAML files
// ============================================================================
pub struct DialectPluginLoader;
#[derive(Debug)]
pub struct LoadResult {
pub loaded: Vec<DialectKind>,
pub errors: Vec<LoadError>,
pub skipped: Vec<PathBuf>,
}
impl DialectPluginLoader {
pub fn scan_and_load(registry: &DialectRegistry, plugin_dirs: &[PathBuf]) -> LoadResult {
let mut result = LoadResult { loaded: Vec::new(), errors: Vec::new(), skipped: Vec::new() };
for dir in plugin_dirs {
if !dir.exists() {
continue;
}
let entries = match fs::read_dir(dir) {
Ok(entries) => entries,
Err(e) => {
result.errors.push(LoadError { path: dir.clone(), error: format!("Cannot read directory: {e}") });
continue;
}
};
for entry in entries {
let entry = match entry {
Ok(e) => e,
Err(_) => continue,
};
let path = entry.path();
if !path.is_file() {
continue;
}
let file_name = path.file_stem().and_then(|s| s.to_str()).unwrap_or("");
let extension = path.extension().and_then(|s| s.to_str()).unwrap_or("");
if !matches!(extension, "yaml" | "yml") {
continue;
}
match Self::load_file(&path) {
Ok((kind, yaml, descriptor)) => {
registry.register(file_name, kind, descriptor, yaml, Some(path.clone()));
result.loaded.push(kind);
}
Err(e) => {
result.errors.push(LoadError { path: path.clone(), error: e });
}
}
}
}
result
}
pub fn load_file(path: &Path) -> Result<(DialectKind, DialectYaml, DialectCapabilityDescriptor), String> {
let content = fs::read_to_string(path).map_err(|e| format!("Cannot read file: {e}"))?;
Self::load_from_string(&content, Some(path))
}
pub fn load_from_string(
yaml_str: &str,
source_path: Option<&Path>,
) -> Result<(DialectKind, DialectYaml, DialectCapabilityDescriptor), String> {
let parsed: DialectYaml = serde_yaml::from_str(yaml_str).map_err(|e| format!("YAML parse error: {e}"))?;
let kind = parsed.dialect_kind().ok_or_else(|| {
format!(
"Unknown dialect name '{}' in {}",
parsed.dialect.name,
source_path.map_or_else(|| "<string>".to_string(), |p| p.display().to_string())
)
})?;
let validation_errors = parsed.validate();
if !validation_errors.is_empty() {
let msgs: Vec<String> = validation_errors.iter().map(|e| e.to_string()).collect();
return Err(format!("Validation errors: {}", msgs.join("; ")));
}
let descriptor = parsed.to_descriptor(kind);
Ok((kind, parsed, descriptor))
}
pub fn load_directory(registry: &DialectRegistry, dir: &Path) -> LoadResult {
Self::scan_and_load(registry, &[dir.to_path_buf()])
}
}
// ============================================================================
// Fallback: use hardcoded descriptors when YAML is unavailable
// ============================================================================
pub fn resolve_descriptor(kind: DialectKind, registry: &DialectRegistry) -> DialectCapabilityDescriptor {
if let Some(desc) = registry.get_descriptor(kind.label()) {
return desc;
}
DialectCapabilityDescriptor::for_dialect(kind)
}
pub fn resolve_descriptor_for_db(
db_type: crate::models::connection::DatabaseType,
registry: &DialectRegistry,
) -> DialectCapabilityDescriptor {
if let Some(desc) = registry.get_descriptor_for_db(db_type) {
return desc;
}
let kind = DialectKind::from_database_type(db_type);
DialectCapabilityDescriptor::for_dialect(kind)
}
// ============================================================================
// Tests
// ============================================================================
#[cfg(test)]
mod tests {
use super::*;
use std::io::Write;
fn temp_dialect_dir() -> PathBuf {
let stamp = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos();
let dir = std::env::temp_dir().join(format!("dbx-dialect-test-{}-{stamp}", std::process::id()));
fs::create_dir_all(&dir).unwrap();
dir
}
fn write_temp_yaml(dir: &Path, name: &str, dialect_name: &str) -> PathBuf {
let file_path = dir.join(name);
let yaml_content = format!(
r#"
dialect:
name: "{dialect_name}"
versions:
- version: "1.0"
identifier_rules:
quote_char: "\""
max_length: 64
"#
);
let mut file = fs::File::create(&file_path).unwrap();
file.write_all(yaml_content.as_bytes()).unwrap();
file_path
}
fn cleanup_temp_dir(dir: &Path) {
let _ = fs::remove_dir_all(dir);
}
#[test]
fn load_valid_yaml_file() {
let dir = temp_dialect_dir();
let path = write_temp_yaml(&dir, "dialect_postgresql.yaml", "PostgreSQL");
let result = DialectPluginLoader::load_file(&path);
cleanup_temp_dir(&dir);
assert!(result.is_ok());
let (kind, _yaml, desc) = result.unwrap();
assert_eq!(kind, DialectKind::Postgres);
assert_eq!(desc.dialect, DialectKind::Postgres);
}
#[test]
fn load_valid_yaml_file_mysql() {
let dir = temp_dialect_dir();
let path = write_temp_yaml(&dir, "dialect_mysql.yaml", "MySQL");
let result = DialectPluginLoader::load_file(&path);
cleanup_temp_dir(&dir);
assert!(result.is_ok());
let (kind, _, _) = result.unwrap();
assert_eq!(kind, DialectKind::Mysql);
}
#[test]
fn load_invalid_dialect_name() {
let dir = temp_dialect_dir();
let path = write_temp_yaml(&dir, "dialect_unknown.yaml", "UnknownDB");
let result = DialectPluginLoader::load_file(&path);
cleanup_temp_dir(&dir);
assert!(result.is_err());
}
#[test]
fn load_invalid_yaml_syntax() {
let dir = temp_dialect_dir();
let path = dir.join("dialect_bad.yaml");
let mut file = fs::File::create(&path).unwrap();
file.write_all(b"dialect: [invalid: yaml: syntax:").unwrap();
let result = DialectPluginLoader::load_file(&path);
cleanup_temp_dir(&dir);
assert!(result.is_err());
}
#[test]
fn registry_register_and_get() {
let registry = DialectRegistry::new();
assert!(registry.is_empty());
let desc = DialectCapabilityDescriptor::for_dialect(DialectKind::Mysql);
let yaml = DialectYaml {
dialect: super::super::dialect_yaml::DialectMeta {
name: "MySQL".to_string(),
display_name: Some("MySQL".to_string()),
versions: vec![],
},
identifier_rules: super::super::dialect_yaml::IdentifierRules {
quote_char: "`".to_string(),
case_sensitive: false,
max_length: 64,
},
..Default::default()
};
registry.register_descriptor("MySQL", desc, yaml);
assert_eq!(registry.len(), 1);
assert!(registry.has("MySQL"));
assert!(!registry.has("PostgreSQL"));
let loaded = registry.get("MySQL").unwrap();
assert_eq!(loaded.dialect_name, "MySQL");
registry.unregister("MySQL");
assert!(registry.is_empty());
}
#[test]
fn registry_fallback_resolve() {
let registry = DialectRegistry::new();
let desc = resolve_descriptor(DialectKind::Mysql, &registry);
assert!(desc.has_capability(super::super::descriptor::CAP_ADD_COLUMN));
}
#[test]
fn registry_all_kinds() {
let registry = DialectRegistry::new();
let desc = DialectCapabilityDescriptor::for_dialect(DialectKind::Mysql);
let yaml = DialectYaml {
dialect: super::super::dialect_yaml::DialectMeta {
name: "MySQL".to_string(),
display_name: None,
versions: vec![],
},
identifier_rules: super::super::dialect_yaml::IdentifierRules {
quote_char: "`".to_string(),
case_sensitive: false,
max_length: 64,
},
..Default::default()
};
registry.register_descriptor("MySQL", desc, yaml);
let names = registry.all_names();
assert_eq!(names, vec!["mysql"]);
}
}