use super::driver::{SchemaConnection, SchemaDriver};
use crate::datasource::DatasourceId;
use crate::error::BaseError;
use crate::table::TableDefinition;
use sqlx::FromRow;
use std::collections::BTreeMap;
use std::time::{SystemTime, UNIX_EPOCH};
pub(crate) const BINDING_TABLE: &str = "_yang_schema_binding";
#[cfg(feature = "mysql")]
const BINDING_TABLE_DDL_MYSQL: &str = "CREATE TABLE IF NOT EXISTS `_yang_schema_binding` (\
`datasource` VARCHAR(32) NOT NULL, \
`table_name` VARCHAR(128) NOT NULL, \
`mode` VARCHAR(16) NOT NULL, \
`fingerprint` VARCHAR(64) NOT NULL, \
`adopted_at` BIGINT NOT NULL, \
PRIMARY KEY (`datasource`, `table_name`)\
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4";
#[cfg(feature = "postgres")]
const BINDING_TABLE_DDL_POSTGRES: &str = "CREATE TABLE IF NOT EXISTS \"_yang_schema_binding\" (\
\"datasource\" VARCHAR(32) NOT NULL, \
\"table_name\" VARCHAR(128) NOT NULL, \
\"mode\" VARCHAR(16) NOT NULL, \
\"fingerprint\" VARCHAR(64) NOT NULL, \
\"adopted_at\" BIGINT NOT NULL, \
PRIMARY KEY (\"datasource\", \"table_name\")\
)";
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum SchemaBindingMode {
Adopted,
Managed,
}
impl SchemaBindingMode {
pub(crate) fn as_str(self) -> &'static str {
match self {
Self::Adopted => "adopted",
Self::Managed => "managed",
}
}
fn parse(value: &str) -> Result<Self, BaseError> {
match value {
"adopted" => Ok(Self::Adopted),
"managed" => Ok(Self::Managed),
other => Err(BaseError::DatabaseInitFailed(format!(
"未知 schema binding 模式: {other}"
))),
}
}
}
#[derive(Debug, Clone)]
pub(crate) struct BindingRecord {
pub(crate) mode: SchemaBindingMode,
pub(crate) fingerprint: String,
}
#[derive(Debug, Clone)]
pub(crate) struct BindingUpdate {
pub(crate) table: String,
pub(crate) mode: SchemaBindingMode,
pub(crate) fingerprint: String,
pub(crate) adopted_at: i64,
pub(crate) newly_bound: bool,
}
#[derive(FromRow)]
struct BindingRow {
table_name: String,
mode: String,
fingerprint: String,
}
pub(crate) async fn ensure_binding_table(
driver: SchemaDriver,
connection: &mut SchemaConnection<'_>,
) -> Result<(), BaseError> {
connection
.execute(match driver {
#[cfg(feature = "mysql")]
SchemaDriver::MySql => BINDING_TABLE_DDL_MYSQL,
#[cfg(feature = "postgres")]
SchemaDriver::PostgreSql => BINDING_TABLE_DDL_POSTGRES,
})
.await
}
pub(crate) async fn load_bindings(
connection: &mut SchemaConnection<'_>,
datasource: &DatasourceId,
) -> Result<BTreeMap<String, BindingRecord>, BaseError> {
let rows = match connection {
#[cfg(feature = "mysql")]
SchemaConnection::MySql(connection) => {
sqlx::query_as::<_, BindingRow>(
"SELECT CAST(table_name AS CHAR) AS table_name, \
CAST(mode AS CHAR) AS mode, \
CAST(fingerprint AS CHAR) AS fingerprint \
FROM `_yang_schema_binding` WHERE datasource = ?",
)
.bind(datasource.as_str())
.fetch_all(&mut **connection)
.await
}
#[cfg(feature = "postgres")]
SchemaConnection::PostgreSql(connection) => {
sqlx::query_as::<_, BindingRow>(
"SELECT table_name, mode, fingerprint \
FROM \"_yang_schema_binding\" WHERE datasource = $1",
)
.bind(datasource.as_str())
.fetch_all(&mut **connection)
.await
}
}
.map_err(|error| BaseError::DatabaseQueryFailed(error.into()))?;
let mut bindings = BTreeMap::new();
for row in rows {
bindings.insert(
row.table_name,
BindingRecord {
mode: SchemaBindingMode::parse(&row.mode)?,
fingerprint: row.fingerprint,
},
);
}
Ok(bindings)
}
pub(crate) async fn upsert_bindings(
connection: &mut SchemaConnection<'_>,
datasource: &DatasourceId,
updates: &[BindingUpdate],
) -> Result<(), BaseError> {
for update in updates {
let result = match connection {
#[cfg(feature = "mysql")]
SchemaConnection::MySql(connection) => sqlx::query(
"INSERT INTO `_yang_schema_binding` \
(datasource, table_name, mode, fingerprint, adopted_at) \
VALUES (?, ?, ?, ?, ?) \
ON DUPLICATE KEY UPDATE mode = VALUES(mode), \
fingerprint = VALUES(fingerprint)",
)
.bind(datasource.as_str())
.bind(&update.table)
.bind(update.mode.as_str())
.bind(&update.fingerprint)
.bind(update.adopted_at)
.execute(&mut **connection)
.await
.map(|_| ()),
#[cfg(feature = "postgres")]
SchemaConnection::PostgreSql(connection) => sqlx::query(
"INSERT INTO \"_yang_schema_binding\" \
(datasource, table_name, mode, fingerprint, adopted_at) \
VALUES ($1, $2, $3, $4, $5) \
ON CONFLICT (datasource, table_name) DO UPDATE SET \
mode = EXCLUDED.mode, fingerprint = EXCLUDED.fingerprint",
)
.bind(datasource.as_str())
.bind(&update.table)
.bind(update.mode.as_str())
.bind(&update.fingerprint)
.bind(update.adopted_at)
.execute(&mut **connection)
.await
.map(|_| ()),
};
result.map_err(|error| BaseError::DatabaseExecuteFailed(error.into()))?;
}
Ok(())
}
pub(crate) fn table_fingerprint(
driver: SchemaDriver,
definition: &TableDefinition,
) -> Result<String, BaseError> {
let config = definition.shared_config();
let signature = driver.dialect().table_signature(config.as_ref())?;
Ok(format!("{:016x}", fnv1a_64(signature.as_bytes())))
}
pub(crate) fn now_unix_seconds() -> i64 {
SystemTime::now()
.duration_since(UNIX_EPOCH)
.map_or(0, |duration| duration.as_secs() as i64)
}
fn fnv1a_64(bytes: &[u8]) -> u64 {
let mut hash: u64 = 0xcbf29ce484222325;
for byte in bytes {
hash ^= u64::from(*byte);
hash = hash.wrapping_mul(0x100000001b3);
}
hash
}