Skip to content

armgit / dbx

Public Imported from GitHub
0

25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。

feat(sqlserver): temporal table DDL and history links

zipg14c152f1eb17
diff --git a/crates/dbx-core/src/schema/mod.rs b/crates/dbx-core/src/schema/mod.rs
index 9e702edb3d..9ed251911b 100644
--- a/crates/dbx-core/src/schema/mod.rs
+++ b/crates/dbx-core/src/schema/mod.rs
@@ -25,6 +25,8 @@ mod mongodb_columns;
pub mod plugin_metadata;
#[cfg(test)]
mod plugin_metadata_tests;
+#[cfg(test)]
+mod sqlserver_temporal_ddl_tests;
macro_rules! extract_pool {
($pool:expr, $variant:ident) => {
@@ -9124,15 +9126,34 @@ struct TableDdlOptions {
include_postgres_access: bool,
include_partitions: bool,
portable_oracle: bool,
+ include_sqlserver_temporal: bool,
}
impl TableDdlOptions {
- const SINGLE_RELATION: Self =
- Self { include_postgres_access: false, include_partitions: false, portable_oracle: false };
- const RELATION_EXPORT: Self =
- Self { include_postgres_access: false, include_partitions: false, portable_oracle: true };
- const EXPORT: Self = Self { include_postgres_access: false, include_partitions: true, portable_oracle: true };
- const DISPLAY: Self = Self { include_postgres_access: true, include_partitions: true, portable_oracle: false };
+ const SINGLE_RELATION: Self = Self {
+ include_postgres_access: false,
+ include_partitions: false,
+ portable_oracle: false,
+ include_sqlserver_temporal: false,
+ };
+ const RELATION_EXPORT: Self = Self {
+ include_postgres_access: false,
+ include_partitions: false,
+ portable_oracle: true,
+ include_sqlserver_temporal: false,
+ };
+ const EXPORT: Self = Self {
+ include_postgres_access: false,
+ include_partitions: true,
+ portable_oracle: true,
+ include_sqlserver_temporal: false,
+ };
+ const DISPLAY: Self = Self {
+ include_postgres_access: true,
+ include_partitions: true,
+ portable_oracle: false,
+ include_sqlserver_temporal: true,
+ };
}
pub async fn get_table_ddl_core(
@@ -9400,7 +9421,8 @@ async fn get_table_ddl_once(
}
if let Some(client) = extract_pool!(pool_handle.as_ref(), SqlServer) {
let mut client = lock_sqlserver_metadata_client(&client).await?;
- return build_sqlserver_ddl(&mut client, schema, table).await;
+ return build_sqlserver_ddl_with_temporal(&mut client, schema, table, options.include_sqlserver_temporal)
+ .await;
}
if let Some(client) = extract_pool!(pool_handle.as_ref(), Agent) {
if let Some(config) = db_config.as_ref().filter(|config| is_agent_postgres_metadata_fallback_config(config))
@@ -14844,6 +14866,19 @@ fn render_postgres_table_ddl_with_constraints_and_partition_info(
ddl
}
+fn sqlserver_temporal_period_mismatches(
+ temporal: &db::sqlserver::SqlServerTemporalTableMetadata,
+ generated_clauses: &HashMap<String, String>,
+) -> bool {
+ [(&temporal.start_column, "START"), (&temporal.end_column, "END")].into_iter().any(|(column, kind)| {
+ column.as_deref().is_some_and(|name| {
+ generated_clauses
+ .get(name)
+ .is_some_and(|clause| !clause.starts_with(&format!("GENERATED ALWAYS AS ROW {kind}")))
+ })
+ })
+}
+
fn sqlserver_identity_clause(extra: Option<&str>) -> Option<String> {
let extra = extra?.trim();
let lower = extra.to_ascii_lowercase();
@@ -14877,6 +14912,15 @@ pub async fn build_sqlserver_ddl(
client: &mut db::sqlserver::SqlServerClient,
schema: &str,
table: &str,
+) -> Result<String, String> {
+ build_sqlserver_ddl_with_temporal(client, schema, table, false).await
+}
+
+async fn build_sqlserver_ddl_with_temporal(
+ client: &mut db::sqlserver::SqlServerClient,
+ schema: &str,
+ table: &str,
+ include_temporal: bool,
) -> Result<String, String> {
// The computed-column definitions come from the same metadata query as the
// columns, so the DDL path reads the richer driver record instead of the
@@ -14885,6 +14929,8 @@ pub async fn build_sqlserver_ddl(
let indexes = db::sqlserver::list_indexes(client, schema, table).await?;
let fkeys = db::sqlserver::list_foreign_keys(client, schema, table).await?;
let table_comment = db::sqlserver::get_table_comment(client, schema, table).await?;
+ let temporal =
+ if include_temporal { db::sqlserver::get_temporal_table_metadata(client, schema, table).await? } else { None };
let columns = metadata.iter().map(|metadata| metadata.column.clone()).collect::<Vec<_>>();
let computed_clauses = metadata
@@ -14899,17 +14945,56 @@ pub async fn build_sqlserver_ddl(
})
.collect::<HashMap<_, _>>();
- Ok(render_sqlserver_table_ddl_with_computed(
+ let generated_clauses = if include_temporal {
+ metadata
+ .iter()
+ .filter_map(|column| {
+ let kind = match column.generated_always_type {
+ 1 => "START",
+ 2 => "END",
+ _ => return None,
+ };
+ Some((
+ column.column.name.clone(),
+ format!("GENERATED ALWAYS AS ROW {kind}{}", if column.is_hidden { " HIDDEN" } else { "" }),
+ ))
+ })
+ .collect::<HashMap<_, _>>()
+ } else {
+ HashMap::new()
+ };
+ if include_temporal && !generated_clauses.is_empty() && temporal.is_none() {
+ return Err("SQL Server temporal period metadata is unavailable".to_string());
+ }
+ if let Some(temporal) = temporal.as_ref() {
+ if sqlserver_temporal_period_mismatches(temporal, &generated_clauses) {
+ return Err(
+ "SQL Server temporal period and column metadata do not match; refresh the table definition".to_string()
+ );
+ }
+ }
+ Ok(render_sqlserver_table_ddl_details(
schema,
table,
&columns,
- &computed_clauses,
&indexes,
&fkeys,
table_comment.as_deref(),
+ SqlServerDdlDetails {
+ computed_clauses: Some(&computed_clauses),
+ generated_clauses: Some(&generated_clauses),
+ temporal: temporal.as_ref(),
+ },
))
}
+#[derive(Default)]
+struct SqlServerDdlDetails<'a> {
+ computed_clauses: Option<&'a HashMap<String, String>>,
+ generated_clauses: Option<&'a HashMap<String, String>>,
+ temporal: Option<&'a db::sqlserver::SqlServerTemporalTableMetadata>,
+}
+
fn sqlserver_fk_action_clause(kind: &str, value: Option<&str>) -> String {
let Some(value) = value else {
return String::new();
@@ -14945,17 +15030,57 @@ pub fn render_sqlserver_table_ddl_with_computed(
indexes: &[db::IndexInfo],
fkeys: &[db::ForeignKeyInfo],
table_comment: Option<&str>,
+) -> String {
+ render_sqlserver_table_ddl_details(
+ schema,
+ table,
+ columns,
+ indexes,
+ fkeys,
+ table_comment,
+ SqlServerDdlDetails { computed_clauses: Some(computed_clauses), ..Default::default() },
+ )
+}
+
+fn render_sqlserver_table_ddl_details(
+ schema: &str,
+ table: &str,
+ columns: &[db::ColumnInfo],
+ indexes: &[db::IndexInfo],
+ fkeys: &[db::ForeignKeyInfo],
+ table_comment: Option<&str>,
+ details: SqlServerDdlDetails<'_>,
) -> String {
let table_name = format!("{}.{}", sqlserver_ident(schema), sqlserver_ident(table));
let mut ddl = format!("CREATE TABLE {table_name} (\n");
+ if let Some(temporal) = details.temporal {
+ if let (Some(schema), Some(table)) = (&temporal.parent_schema, &temporal.parent_table) {
+ let parent = format!("{}.{}", sqlserver_ident(schema), sqlserver_ident(table)).chars().fold(
+ String::new(),
+ |mut text, character| {
+ if character.is_control() || matches!(character, '\u{2028}' | '\u{2029}') {
+ text.extend(character.escape_default());
+ } else {
+ text.push(character);
+ }
+ text
+ },
+ );
+ ddl.insert_str(0, &format!("-- History table for {parent}\n"));
+ }
+ }
let col_lines: Vec<String> = columns
.iter()
.map(|c| {
// A computed column can never have a default, and its `data_type`
// is only the derived result type: rendering either would emit a
// table that differs from the one being scripted.
- if let Some(clause) =
- computed_clauses.get(&c.name).map(String::as_str).map(str::trim).filter(|clause| !clause.is_empty())
+ if let Some(clause) = details
+ .computed_clauses
+ .and_then(|clauses| clauses.get(&c.name))
+ .map(String::as_str)
+ .map(str::trim)
+ .filter(|clause| !clause.is_empty())
{
let mut line = format!(" {} {clause}", sqlserver_ident(&c.name));
if !c.is_nullable {
@@ -14967,6 +15092,9 @@ pub fn render_sqlserver_table_ddl_with_computed(
if let Some(identity) = sqlserver_identity_clause(c.extra.as_deref()) {
line.push_str(&format!(" {identity}"));
}
+ if let Some(clause) = details.generated_clauses.and_then(|clauses| clauses.get(&c.name)) {
+ line.push_str(&format!(" {clause}"));
+ }
if !c.is_nullable {
line.push_str(" NOT NULL");
}
@@ -15007,7 +15135,34 @@ pub fn render_sqlserver_table_ddl_with_computed(
ref_columns
));
}
- ddl.push_str("\n);\n");
+ if let Some(temporal) = details.temporal {
+ if let (Some(start), Some(end)) = (&temporal.start_column, &temporal.end_column) {
+ ddl.push_str(&format!(
+ ",\n PERIOD FOR SYSTEM_TIME ({}, {})",
+ sqlserver_ident(start),
+ sqlserver_ident(end)
+ ));
+ }
+ }
+ ddl.push_str("\n)");
+ if let Some(temporal) = details.temporal.filter(|metadata| metadata.temporal_type == 2) {
+ if let (Some(schema), Some(table)) = (&temporal.history_schema, &temporal.history_table) {
+ ddl.push_str(&format!(
+ " WITH (SYSTEM_VERSIONING = ON (HISTORY_TABLE = {}.{}",
+ sqlserver_ident(schema),
+ sqlserver_ident(table)
+ ));
+ if let (Some(period), Some(unit)) =
+ (temporal.retention_period.filter(|period| *period >= 0), temporal.retention_unit.as_deref())
+ {
+ if matches!(unit, "DAY" | "WEEK" | "MONTH" | "YEAR") {
+ ddl.push_str(&format!(", HISTORY_RETENTION_PERIOD = {period} {unit}"));
+ }
+ }
+ ddl.push_str("))");
+ }
+ }
+ ddl.push_str(";\n");
if let Some(comment) = table_comment.filter(|comment| !comment.trim().is_empty()) {
ddl.push_str(&format!(
diff --git a/crates/dbx-core/src/schema/sqlserver_temporal_ddl_tests.rs b/crates/dbx-core/src/schema/sqlserver_temporal_ddl_tests.rs
new file mode 100644
index 0000000000..0b976e717e
--- /dev/null
+++ b/crates/dbx-core/src/schema/sqlserver_temporal_ddl_tests.rs
@@ -0,0 +1,127 @@
+use super::{render_sqlserver_table_ddl_details, sqlserver_temporal_period_mismatches, SqlServerDdlDetails};
+use crate::db::{sqlserver::SqlServerTemporalTableMetadata, ColumnInfo};
+use std::collections::HashMap;
+
+fn metadata() -> SqlServerTemporalTableMetadata {
+ SqlServerTemporalTableMetadata {
+ temporal_type: 2,
+ start_column: Some("ValidFrom".into()),
+ end_column: Some("ValidTo".into()),
+ history_schema: Some("History".into()),
+ history_table: Some("Versions".into()),
+ parent_schema: None,
+ parent_table: None,
+ retention_period: None,
+ retention_unit: None,
+ }
+}
+
+fn render(temporal: &SqlServerTemporalTableMetadata) -> String {
+ let columns = [
+ ColumnInfo { name: "id".into(), data_type: "int".into(), is_primary_key: true, ..Default::default() },
+ ColumnInfo { name: "ValidFrom".into(), data_type: "datetime2(7)".into(), ..Default::default() },
+ ColumnInfo { name: "ValidTo".into(), data_type: "datetime2(7)".into(), ..Default::default() },
+ ];
+ let generated = HashMap::from([
+ ("ValidFrom".into(), "GENERATED ALWAYS AS ROW START HIDDEN".into()),
+ ("ValidTo".into(), "GENERATED ALWAYS AS ROW END".into()),
+ ]);
+ render_sqlserver_table_ddl_details(
+ "dbo",
+ "Current",
+ &columns,
+ &[],
+ &[],
+ None,
+ SqlServerDdlDetails { generated_clauses: Some(&generated), temporal: Some(temporal), ..Default::default() },
+ )
+}
+
+#[test]
+fn period_columns_without_generated_clauses_are_not_a_mismatch() {
+ let temporal = metadata();
+ let unrelated = HashMap::from([("unrelated".to_string(), "GENERATED ALWAYS AS ROW END".to_string())]);
+ assert!(!sqlserver_temporal_period_mismatches(&temporal, &unrelated));
+ assert!(!sqlserver_temporal_period_mismatches(&temporal, &HashMap::new()));
+}
+
+#[test]
+fn generated_clause_with_wrong_period_kind_is_a_mismatch() {
+ let temporal = metadata();
+ let swapped = HashMap::from([
+ ("ValidFrom".to_string(), "GENERATED ALWAYS AS ROW END".to_string()),
+ ("ValidTo".to_string(), "GENERATED ALWAYS AS ROW START".to_string()),
+ ]);
+ assert!(sqlserver_temporal_period_mismatches(&temporal, &swapped));
+ let correct = HashMap::from([
+ ("ValidFrom".to_string(), "GENERATED ALWAYS AS ROW START HIDDEN".to_string()),
+ ("ValidTo".to_string(), "GENERATED ALWAYS AS ROW END".to_string()),
+ ]);
+ assert!(!sqlserver_temporal_period_mismatches(&temporal, &correct));
+}
+
+#[test]
+fn current_temporal_ddl_keeps_period_generation_visibility_and_history_identity() {
+ let ddl = render(&metadata());
+ assert!(ddl.contains("[ValidFrom] datetime2(7) GENERATED ALWAYS AS ROW START HIDDEN NOT NULL"));
+ assert!(ddl.contains("[ValidTo] datetime2(7) GENERATED ALWAYS AS ROW END NOT NULL"));
+ assert!(ddl.contains("PERIOD FOR SYSTEM_TIME ([ValidFrom], [ValidTo])"));
+ assert!(ddl.contains("WITH (SYSTEM_VERSIONING = ON (HISTORY_TABLE = [History].[Versions]))"));
+}
+
+#[test]
+fn disabled_versioning_keeps_the_period_without_reenabling_history() {
+ let mut temporal = metadata();
+ temporal.temporal_type = 0;
+ temporal.history_schema = None;
+ temporal.history_table = None;
+ let ddl = render(&temporal);
+ assert!(ddl.contains("PERIOD FOR SYSTEM_TIME ([ValidFrom], [ValidTo])"));
+ assert!(!ddl.contains("SYSTEM_VERSIONING"));
+}
+
+#[test]
+fn history_retention_is_explicit_only_for_finite_periods() {
+ let mut temporal = metadata();
+ temporal.retention_period = Some(6);
+ temporal.retention_unit = Some("MONTH".into());
+ assert!(render(&temporal).contains("HISTORY_RETENTION_PERIOD = 6 MONTH"));
+ temporal.retention_period = Some(-1);
+ temporal.retention_unit = Some("INFINITE".into());
+ assert!(!render(&temporal).contains("HISTORY_RETENTION_PERIOD"));
+}
+
+#[test]
+fn qualified_history_identifiers_escape_brackets() {
+ let mut temporal = metadata();
+ temporal.history_schema = Some("His]t".into());
+ temporal.history_table = Some("V]ersions".into());
+ assert!(render(&temporal).contains("HISTORY_TABLE = [His]]t].[V]]ersions]"));
+}
+
+#[test]
+fn history_relationship_comment_cannot_turn_identifier_newlines_into_sql() {
+ let temporal = SqlServerTemporalTableMetadata {
+ temporal_type: 1,
+ start_column: None,
+ end_column: None,
+ history_schema: None,
+ history_table: None,
+ parent_schema: Some("dbo".into()),
+ parent_table: Some("Current\nDROP TABLE victim;--".into()),
+ retention_period: None,
+ retention_unit: None,
+ };
+ let ddl = render_sqlserver_table_ddl_details(
+ "History",
+ "Versions",
+ &[ColumnInfo { name: "id".into(), data_type: "int".into(), ..Default::default() }],
+ &[],
+ &[],
+ None,
+ SqlServerDdlDetails { temporal: Some(&temporal), ..Default::default() },
+ );
+ assert!(ddl.starts_with("-- History table for [dbo].[Current\\nDROP TABLE victim;--]\nCREATE TABLE"));
+ let statements = sqlparser::parser::Parser::parse_sql(&sqlparser::dialect::MsSqlDialect {}, &ddl).unwrap();
+ assert_eq!(statements.len(), 1);
+}
diff --git a/crates/dbx-core/tests/live_sqlserver_temporal_ddl.rs b/crates/dbx-core/tests/live_sqlserver_temporal_ddl.rs
new file mode 100644
index 0000000000..35a633170f
--- /dev/null
+++ b/crates/dbx-core/tests/live_sqlserver_temporal_ddl.rs
@@ -0,0 +1,110 @@
+use dbx_core::connection::AppState;
+use dbx_core::models::connection::ConnectionConfig;
+use dbx_core::query::execute_sql_statement;
+use dbx_core::storage::Storage;
+use std::sync::Arc;
+
+fn quote(value: &str) -> String {
+ format!("[{}]", value.replace(']', "]]"))
+}
+
+#[tokio::test]
+#[ignore = "requires writable DBX_LIVE_SQLSERVER_HOST/PORT/USER/PASSWORD"]
+async fn live_sqlserver_temporal_display_ddl_replays_period_history_and_disabled_versioning() {
+ let dir = tempfile::tempdir().unwrap();
+ let state = Arc::new(AppState::new(Storage::open(&dir.path().join("dbx.db")).await.unwrap()));
+ let config: ConnectionConfig = serde_json::from_value(serde_json::json!({
+ "id":"temporal-ddl", "name":"Temporal DDL regression", "db_type":"sqlserver",
+ "host":std::env::var("DBX_LIVE_SQLSERVER_HOST").unwrap_or_else(|_|"127.0.0.1".into()),
+ "port":std::env::var("DBX_LIVE_SQLSERVER_PORT").unwrap_or_else(|_|"1433".into()).parse::<u16>().unwrap(),
+ "username":std::env::var("DBX_LIVE_SQLSERVER_USER").unwrap_or_else(|_|"sa".into()),
+ "password":std::env::var("DBX_LIVE_SQLSERVER_PASSWORD").expect("live SQL Server password"),
+ "database":"master", "connect_timeout_secs":15, "query_timeout_secs":60
+ }))
+ .unwrap();
+ state.configs.write().await.insert(config.id.clone(), config.clone());
+ let suffix = uuid::Uuid::new_v4().simple().to_string();
+ let source = format!("dbx_temporal_{suffix}");
+ let restored = format!("dbx_temporal_restore_{suffix}");
+ let history_schema = "His]t_2209";
+ let table = "Current]Table";
+ let history = "Archive]Table";
+ let table_ref = format!("[dbo].{}", quote(table));
+ let history_ref = format!("{}.{}", quote(history_schema), quote(history));
+ for database in [&source, &restored] {
+ execute_sql_statement(
+ &state,
+ &config.id,
+ "master",
+ &format!("CREATE DATABASE {}", quote(database)),
+ None,
+ None,
+ )
+ .await
+ .unwrap();
+ execute_sql_statement(
+ &state,
+ &config.id,
+ database,
+ &format!("CREATE SCHEMA {}", quote(history_schema)),
+ None,
+ None,
+ )
+ .await
+ .unwrap();
+ }
+ let result = async {
+ let create = format!("CREATE TABLE {table_ref} ([id] int NOT NULL PRIMARY KEY,[payload] nvarchar(50),[Start]]At] datetime2(7) GENERATED ALWAYS AS ROW START HIDDEN NOT NULL DEFAULT SYSUTCDATETIME(),[End.At] datetime2(7) GENERATED ALWAYS AS ROW END NOT NULL DEFAULT CONVERT(datetime2(7),'9999-12-31 23:59:59.9999999'),PERIOD FOR SYSTEM_TIME ([Start]]At],[End.At])) WITH (SYSTEM_VERSIONING=ON (HISTORY_TABLE={history_ref},HISTORY_RETENTION_PERIOD=6 MONTHS))");
+ execute_sql_statement(&state, &config.id, &source, &create, None, None).await?;
+ let ddl = dbx_core::schema::get_table_display_ddl_core(&state, &config.id, &source, "dbo", table, None).await?;
+ assert!(ddl.contains("GENERATED ALWAYS AS ROW START HIDDEN"), "{ddl}");
+ assert!(ddl.contains("GENERATED ALWAYS AS ROW END NOT NULL"), "{ddl}");
+ assert!(ddl.contains("PERIOD FOR SYSTEM_TIME ([Start]]At], [End.At])"), "{ddl}");
+ assert!(ddl.contains(&format!("HISTORY_TABLE = {history_ref}")), "{ddl}");
+ assert!(ddl.contains("HISTORY_RETENTION_PERIOD = 6 MONTH"), "{ddl}");
+ // A history definition advertises the reverse relationship. Replaying it
+ // first lets the current-table script bind to the same qualified history.
+ let history_ddl = dbx_core::schema::get_table_display_ddl_core(&state, &config.id, &source, history_schema, history, None).await?;
+ assert!(history_ddl.starts_with(&format!("-- History table for {table_ref}\n")), "{history_ddl}");
+ execute_sql_statement(&state, &config.id, &restored, &history_ddl, None, None).await?;
+ execute_sql_statement(&state, &config.id, &restored, &ddl, None, None).await?;
+ let catalog = execute_sql_statement(&state, &config.id, &restored,
+ "SELECT CAST(t.temporal_type AS int),s.name,h.name,cs.name,ce.name,CAST(t.history_retention_period AS int),t.history_retention_period_unit_desc FROM sys.tables t JOIN sys.periods p ON p.object_id=t.object_id JOIN sys.tables h ON h.object_id=t.history_table_id JOIN sys.schemas s ON s.schema_id=h.schema_id JOIN sys.columns cs ON cs.object_id=p.object_id AND cs.column_id=p.start_column_id JOIN sys.columns ce ON ce.object_id=p.object_id AND ce.column_id=p.end_column_id WHERE t.temporal_type=2", None, None).await?;
+ assert_eq!(catalog.rows[0], vec![serde_json::json!(2),serde_json::json!(history_schema),serde_json::json!(history),serde_json::json!("Start]At"),serde_json::json!("End.At"),serde_json::json!(6),serde_json::json!("MONTH")]);
+ execute_sql_statement(&state, &config.id, &restored, &format!("INSERT INTO {table_ref}([id],[payload]) VALUES(1,N'first')"), None, None).await?;
+ execute_sql_statement(&state, &config.id, &restored, &format!("UPDATE {table_ref} SET [payload]=N'second' WHERE [id]=1"), None, None).await?;
+ let rows = execute_sql_statement(&state, &config.id, &restored, &format!("SELECT [payload] FROM {history_ref}"), None, None).await?;
+ assert_eq!(rows.rows[0][0], serde_json::json!("first"));
+ // Basic/portable definitions must not attach a clone to a source history table.
+ let portable = dbx_core::schema::get_table_export_ddl_core(&state, &config.id, &source, "dbo", table, None).await?;
+ assert!(!portable.contains("PERIOD FOR SYSTEM_TIME"));
+ assert!(!portable.contains("SYSTEM_VERSIONING"));
+ execute_sql_statement(&state, &config.id, &source, &format!("ALTER TABLE {table_ref} SET (SYSTEM_VERSIONING=OFF)"), None, None).await?;
+ let disabled = dbx_core::schema::get_table_display_ddl_core(&state, &config.id, &source, "dbo", table, None).await?;
+ assert!(disabled.contains("PERIOD FOR SYSTEM_TIME"), "{disabled}");
+ assert!(!disabled.contains("SYSTEM_VERSIONING"), "{disabled}");
+ execute_sql_statement(&state, &config.id, &restored, &format!("ALTER TABLE {table_ref} SET (SYSTEM_VERSIONING=OFF); DROP TABLE {table_ref}"), None, None).await?;
+ execute_sql_statement(&state, &config.id, &restored, &disabled, None, None).await?;
+ let state_after = execute_sql_statement(&state, &config.id, &restored, "SELECT CAST(t.temporal_type AS int) FROM sys.tables t JOIN sys.periods p ON p.object_id=t.object_id", None, None).await?;
+ assert_eq!(state_after.rows[0][0], serde_json::json!(0));
+ Ok::<(),String>(())
+ }.await;
+ for database in [&source, &restored] {
+ execute_sql_statement(
+ &state,
+ &config.id,
+ "master",
+ &format!(
+ "ALTER DATABASE {} SET SINGLE_USER WITH ROLLBACK IMMEDIATE; DROP DATABASE {}",
+ quote(database),
+ quote(database)
+ ),
+ None,
+ None,
+ )
+ .await
+ .unwrap();
+ }
+ state.shutdown(std::time::Duration::from_secs(1)).await;
+ result.expect("temporal DDL live regression");
+}
diff --git a/crates/dbx-driver-sqlserver/src/sqlserver.rs b/crates/dbx-driver-sqlserver/src/sqlserver.rs
index bb95ba2a95..3957b75303 100644
--- a/crates/dbx-driver-sqlserver/src/sqlserver.rs
+++ b/crates/dbx-driver-sqlserver/src/sqlserver.rs
@@ -205,6 +205,19 @@ pub struct SqlServerColumnMetadata {
pub computed_clause: Option<String>,
}
+#[derive(Debug, Clone)]
+pub struct SqlServerTemporalTableMetadata {
+ pub temporal_type: i32,
+ pub start_column: Option<String>,
+ pub end_column: Option<String>,
+ pub history_schema: Option<String>,
+ pub history_table: Option<String>,
+ pub parent_schema: Option<String>,
+ pub parent_table: Option<String>,
+ pub retention_period: Option<i32>,
+ pub retention_unit: Option<String>,
+}
+
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, PartialEq, Eq)]
pub struct SqlServerCompletionContext {
pub default_schema: String,
@@ -2928,6 +2941,75 @@ pub async fn get_column_metadata(
Ok(rows.iter().map(sqlserver_column_metadata_from_row).collect())
}
+pub async fn get_temporal_table_metadata(
+ client: &mut SqlServerClient,
+ schema: &str,
+ table: &str,
+) -> Result<Option<SqlServerTemporalTableMetadata>, String> {
+ // Dynamic SQL keeps pre-2016 servers from binding the newer catalog columns.
+ // Retention metadata was added later, so it has its own feature check.
+ let sql = r#"IF OBJECT_ID(N'sys.periods') IS NOT NULL
+BEGIN
+ DECLARE @retention nvarchar(max) = N'CAST(NULL AS int), CAST(NULL AS nvarchar(30))';
+ IF COL_LENGTH(N'sys.tables', N'history_retention_period') IS NOT NULL
+ SET @retention = N'CAST(t.history_retention_period AS int), t.history_retention_period_unit_desc';
+ DECLARE @sql nvarchar(max) = N'
+ SELECT CAST(t.temporal_type AS int), cs.name, ce.name,
+ hs.name, h.name, ps.name, parent.name, ' + @retention + N'
+ FROM sys.tables t
+ JOIN sys.schemas s ON s.schema_id = t.schema_id
+ LEFT JOIN sys.periods p ON p.object_id = t.object_id
+ LEFT JOIN sys.columns cs ON cs.object_id = p.object_id AND cs.column_id = p.start_column_id
+ LEFT JOIN sys.columns ce ON ce.object_id = p.object_id AND ce.column_id = p.end_column_id
+ LEFT JOIN sys.tables h ON h.object_id = t.history_table_id
+ LEFT JOIN sys.schemas hs ON hs.schema_id = h.schema_id
+ LEFT JOIN sys.tables parent ON parent.history_table_id = t.object_id
+ LEFT JOIN sys.schemas ps ON ps.schema_id = parent.schema_id
+ WHERE s.name = COALESCE(NULLIF(@schema, N''''), SCHEMA_NAME()) AND t.name = @table';
+ EXEC sys.sp_executesql @sql, N'@schema nvarchar(128), @table nvarchar(128)', @schema=@P1, @table=@P2;
+END"#;
+ let rows = client
+ .query(sql, &[&schema, &table])
+ .await
+ .map_err(|error| error.to_string())?
+ .into_first_result()
+ .await
+ .map_err(|error| error.to_string())?;
+ let Some(row) = rows.first() else { return Ok(None) };
+ let metadata = SqlServerTemporalTableMetadata {
+ temporal_type: row.get::<i32, _>(0).unwrap_or(0),
+ start_column: row.get::<&str, _>(1).map(str::to_string),
+ end_column: row.get::<&str, _>(2).map(str::to_string),
+ history_schema: row.get::<&str, _>(3).map(str::to_string),
+ history_table: row.get::<&str, _>(4).map(str::to_string),
+ parent_schema: row.get::<&str, _>(5).map(str::to_string),
+ parent_table: row.get::<&str, _>(6).map(str::to_string),
+ retention_period: row.get::<i32, _>(7),
+ retention_unit: row.get::<&str, _>(8).map(str::to_string),
+ };
+ if metadata.temporal_type == 0 && metadata.start_column.is_none() && metadata.end_column.is_none() {
+ return Ok(None);
+ }
+ if metadata.temporal_type == 2
+ && (metadata.start_column.is_none()
+ || metadata.end_column.is_none()
+ || metadata.history_schema.is_none()
+ || metadata.history_table.is_none())
+ {
+ return Err("SQL Server temporal table metadata is incomplete".to_string());
+ }
+ if metadata.temporal_type == 1 && (metadata.parent_schema.is_none() || metadata.parent_table.is_none()) {
+ return Err("SQL Server history table relationship metadata is incomplete".to_string());
+ }
+ if metadata.temporal_type == 2
+ && metadata.retention_period.is_some_and(|period| period >= 0)
+ && !metadata.retention_unit.as_deref().is_some_and(|unit| matches!(unit, "DAY" | "WEEK" | "MONTH" | "YEAR"))
+ {
+ return Err("SQL Server temporal history retention metadata is unavailable or unsupported".to_string());
+ }
+ Ok(Some(metadata))
+}
+
fn sqlserver_column_metadata_from_row(row: &Row) -> SqlServerColumnMetadata {
let base = row.get::<&str, _>(1).unwrap_or("").to_string();
let max_len = row
diff --git a/docs/screenshots/issue-2209-after.jpg b/docs/screenshots/issue-2209-after.jpg
new file mode 100644
index 0000000000..7d965e19e9
Binary files /dev/null and b/docs/screenshots/issue-2209-after.jpg differ
diff --git a/docs/screenshots/issue-2209-before.jpg b/docs/screenshots/issue-2209-before.jpg
new file mode 100644
index 0000000000..138ba962da
Binary files /dev/null and b/docs/screenshots/issue-2209-before.jpg differ
diff --git a/docs/screenshots/issue-2209-history.jpg b/docs/screenshots/issue-2209-history.jpg
new file mode 100644
index 0000000000..273263b6c7
Binary files /dev/null and b/docs/screenshots/issue-2209-history.jpg differ