1419 lines
56 KiB
Rust
1419 lines
56 KiB
Rust
use super::*;
|
|
use crate::data_grid_sql::{DataGridColumnInfo, DataGridTableMeta};
|
|
use crate::models::connection::DatabaseType;
|
|
use serde_json::json;
|
|
|
|
fn column(name: &str, source_index: usize) -> DataGridExtractColumn {
|
|
DataGridExtractColumn { display_name: name.to_string(), source_name: Some(name.to_string()), source_index }
|
|
}
|
|
|
|
fn request(extractor: DataGridExtractorId) -> DataGridExtractRequest {
|
|
DataGridExtractRequest {
|
|
version: DATA_GRID_EXTRACTOR_CONTRACT_VERSION,
|
|
extractor,
|
|
database_type: Some(DatabaseType::Postgres),
|
|
identifier_quote: None,
|
|
table_meta: None,
|
|
columns: vec![column("id", 0), column("name", 1)],
|
|
selected_column_indexes: vec![0, 1],
|
|
rows: vec![vec![json!(1), json!("Ada")], vec![json!(2), json!("Grace, Hopper")]],
|
|
selection_kind: DataGridSelectionKind::Cells,
|
|
options: DataGridExtractorOptions::default(),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn partially_deserialized_options_use_the_canonical_defaults() {
|
|
let options = serde_json::from_value::<DataGridExtractorOptions>(json!({
|
|
"dsv": { "columnSeparator": ";" },
|
|
"sql": { "skipGeneratedColumns": false },
|
|
"json": {}
|
|
}))
|
|
.expect("deserialize partial extractor options");
|
|
|
|
assert_eq!(options.dsv.column_separator, ";");
|
|
assert_eq!(options.dsv.row_separator, "\n");
|
|
assert_eq!(options.dsv.null_text, "NULL");
|
|
assert_eq!(options.dsv.quote, '"');
|
|
assert_eq!(options.dsv.quote_policy, DataGridQuotePolicy::Minimal);
|
|
assert!(!options.dsv.include_column_header);
|
|
assert!(!options.dsv.include_row_header);
|
|
assert!(options.sql.skip_computed_columns);
|
|
assert!(!options.sql.skip_generated_columns);
|
|
assert_eq!(options.sql.insert_mode, crate::data_grid_sql::DataGridCopyInsertMode::Merged);
|
|
assert!(!options.sql.exclude_primary_keys_from_insert);
|
|
assert!(options.sql.include_database_name);
|
|
assert!(options.json.pretty);
|
|
assert!(!options.json.camel_case_field_names);
|
|
}
|
|
|
|
#[test]
|
|
fn insert_database_name_option_handles_engine_namespaces() {
|
|
use crate::data_grid_sql::DataGridCopyInsertMode;
|
|
use crate::sql_dialect::uses_single_row_insert_statements;
|
|
|
|
for (database_type, catalog, schema, qualified, unqualified) in [
|
|
(DatabaseType::Mysql, None, "a`b", "`a``b`.`users`", "`users`"),
|
|
(DatabaseType::Goldendb, None, "app", "`app`.`users`", "`users`"),
|
|
(DatabaseType::Doris, Some("internal"), "app", "`app`.`users`", "`users`"),
|
|
(DatabaseType::StarRocks, None, "app", "`app`.`users`", "`users`"),
|
|
(DatabaseType::Sqlite, None, "main", "\"main\".\"users\"", "\"users\""),
|
|
(DatabaseType::Sqlite, None, "attached", "\"attached\".\"users\"", "\"users\""),
|
|
(DatabaseType::DuckDb, None, "main", "\"main\".\"users\"", "\"users\""),
|
|
(DatabaseType::Oracle, None, "APP", "\"APP\".\"users\"", "\"users\""),
|
|
(DatabaseType::Dameng, None, "APP", "\"APP\".\"users\"", "\"users\""),
|
|
(DatabaseType::Kingbase, None, "audit", "\"audit\".\"users\"", "\"users\""),
|
|
(DatabaseType::Gaussdb, None, "audit", "\"audit\".\"users\"", "\"users\""),
|
|
(DatabaseType::OpenGauss, None, "audit", "\"audit\".\"users\"", "\"users\""),
|
|
(DatabaseType::Db2, None, "APP", "\"APP\".\"users\"", "\"users\""),
|
|
(DatabaseType::StarRocks, Some("iceberg"), "app", "`iceberg`.`app`.`users`", "`users`"),
|
|
(DatabaseType::Postgres, None, "audit", "\"audit\".\"users\"", "\"users\""),
|
|
(DatabaseType::SqlServer, Some("app"), "audit", "[app].[audit].[users]", "[users]"),
|
|
(DatabaseType::Doris, Some("iceberg"), "app", "`iceberg`.`app`.`users`", "`users`"),
|
|
] {
|
|
for include_database_name in [true, false] {
|
|
for insert_mode in [DataGridCopyInsertMode::Merged, DataGridCopyInsertMode::RowByRow] {
|
|
let mut request = request(DataGridExtractorId::SqlInserts);
|
|
request.database_type = Some(database_type);
|
|
request.table_meta = Some(DataGridTableMeta {
|
|
catalog: catalog.map(str::to_owned),
|
|
database: Some("app".to_owned()),
|
|
schema: Some(schema.to_owned()),
|
|
table_name: "users".to_owned(),
|
|
primary_keys: vec![],
|
|
columns: None,
|
|
});
|
|
request.options.sql.include_database_name = include_database_name;
|
|
request.options.sql.insert_mode = insert_mode;
|
|
// Exercise the same camelCase contract sent by the frontend.
|
|
let request = serde_json::from_value(serde_json::to_value(request).unwrap()).unwrap();
|
|
let result = extract_data_grid_selection(request).unwrap();
|
|
let table = if include_database_name { qualified } else { unqualified };
|
|
let statements: Vec<_> = result.text.split(";\n").collect();
|
|
let expected_statement_count = if insert_mode == DataGridCopyInsertMode::RowByRow
|
|
|| uses_single_row_insert_statements(database_type)
|
|
{
|
|
2
|
|
} else {
|
|
1
|
|
};
|
|
assert_eq!(statements.len(), expected_statement_count);
|
|
for statement in statements {
|
|
assert!(statement.starts_with(&format!("INSERT INTO {table} (")), "{statement}");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn insert_database_name_option_uses_database_when_schema_is_absent() {
|
|
use crate::data_grid_sql::DataGridCopyInsertMode;
|
|
|
|
for database_type in [DatabaseType::Mysql, DatabaseType::Goldendb, DatabaseType::Doris, DatabaseType::StarRocks] {
|
|
for (database, schema, qualified) in [
|
|
(Some("a`b"), None, "`a``b`.`users`"),
|
|
(Some("app"), Some(""), "`app`.`users`"),
|
|
(Some("app"), Some(" "), "`app`.`users`"),
|
|
(Some("app"), Some("other"), "`other`.`users`"),
|
|
(None, Some("other"), "`other`.`users`"),
|
|
(None, None, "`users`"),
|
|
(Some(" "), None, "`users`"),
|
|
] {
|
|
for include_database_name in [true, false] {
|
|
for insert_mode in [DataGridCopyInsertMode::Merged, DataGridCopyInsertMode::RowByRow] {
|
|
let mut request = request(DataGridExtractorId::SqlInserts);
|
|
request.database_type = Some(database_type);
|
|
request.table_meta = Some(DataGridTableMeta {
|
|
catalog: None,
|
|
database: database.map(str::to_owned),
|
|
schema: schema.map(str::to_owned),
|
|
table_name: "users".to_owned(),
|
|
primary_keys: vec![],
|
|
columns: None,
|
|
});
|
|
request.options.sql.include_database_name = include_database_name;
|
|
request.options.sql.insert_mode = insert_mode;
|
|
let request = serde_json::from_value(serde_json::to_value(request).unwrap()).unwrap();
|
|
let result = extract_data_grid_selection(request).unwrap();
|
|
let table = if include_database_name { qualified } else { "`users`" };
|
|
for statement in result.text.split(";\n") {
|
|
assert!(statement.starts_with(&format!("INSERT INTO {table} (")), "{statement}");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn postgres_insert_can_omit_schema_namespace() {
|
|
for schema in [Some("dbx_dst_ccfebf6b"), None] {
|
|
for include_database_name in [true, false] {
|
|
let mut request = request(DataGridExtractorId::SqlInserts);
|
|
request.database_type = Some(DatabaseType::Postgres);
|
|
request.table_meta = Some(DataGridTableMeta {
|
|
catalog: None,
|
|
database: Some("app".to_owned()),
|
|
schema: schema.map(str::to_owned),
|
|
table_name: "users".to_owned(),
|
|
primary_keys: vec![],
|
|
columns: None,
|
|
});
|
|
request.options.sql.include_database_name = include_database_name;
|
|
let result = extract_data_grid_selection(request).unwrap();
|
|
let table =
|
|
if include_database_name && schema.is_some() { r#""dbx_dst_ccfebf6b"."users""# } else { r#""users""# };
|
|
assert!(result.text.starts_with(&format!("INSERT INTO {table} (")), "{}", result.text);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn extracts_csv_with_minimal_standard_quoting() {
|
|
let result = extract_data_grid_selection(request(DataGridExtractorId::Csv)).expect("CSV extraction");
|
|
assert_eq!(result.text, "1,Ada\n2,\"Grace, Hopper\"");
|
|
}
|
|
|
|
#[test]
|
|
fn extracts_raw_values_without_escaping_quotes() {
|
|
let mut request = request(DataGridExtractorId::Raw);
|
|
request.columns = vec![column("payload", 0)];
|
|
request.selected_column_indexes = vec![0];
|
|
request.rows = vec![vec![json!(r#"{"msg":"success"}"#)]];
|
|
|
|
let result = extract_data_grid_selection(request).expect("raw extraction");
|
|
|
|
assert_eq!(result.text, r#"{"msg":"success"}"#);
|
|
assert_eq!(result.mime_type, "text/plain");
|
|
}
|
|
|
|
#[test]
|
|
fn tsv_and_pipe_emit_embedded_quotes_verbatim_while_csv_escapes_them() {
|
|
// Reproduces #10087: a value that is itself wrapped in double quotes (e.g.
|
|
// MySQL `SELECT CONCAT('"', id, '"')`) must copy out unchanged from the grid's
|
|
// default multi-cell (TSV) copy, instead of being wrapped and doubled.
|
|
let quoted = r#""9932b4d2ad1c4ff88b5bfe1690ee1bb8""#;
|
|
|
|
for (extractor, separator) in [(DataGridExtractorId::Tsv, "\t"), (DataGridExtractorId::PipeSeparated, "|")] {
|
|
let mut request = request(extractor);
|
|
request.rows = vec![vec![json!(1), json!(quoted)]];
|
|
let result = extract_data_grid_selection(request).expect("plain delimited extraction");
|
|
assert_eq!(result.text, format!("1{separator}{quoted}"), "extractor {extractor:?} must not escape quotes");
|
|
}
|
|
|
|
// CSV is an RFC4180 format, so the same value must still be quoted and doubled.
|
|
let mut csv = request(DataGridExtractorId::Csv);
|
|
csv.rows = vec![vec![json!(1), json!(quoted)]];
|
|
let csv_result = extract_data_grid_selection(csv).expect("CSV extraction");
|
|
assert_eq!(csv_result.text, format!("1,\"{}\"", quoted.replace('"', "\"\"")));
|
|
}
|
|
|
|
#[test]
|
|
fn tsv_still_quotes_values_that_would_break_the_row_shape() {
|
|
// Relaxing the quote-character trigger must not stop quoting on the actual
|
|
// separator / line breaks, which would otherwise corrupt the TSV structure.
|
|
let mut request = request(DataGridExtractorId::Tsv);
|
|
request.rows = vec![vec![json!(1), json!("a\tb\nc")]];
|
|
let result = extract_data_grid_selection(request).expect("TSV extraction");
|
|
assert_eq!(result.text, "1\t\"a\tb\nc\"");
|
|
}
|
|
|
|
#[test]
|
|
fn raw_exports_null_as_an_empty_value() {
|
|
let mut request = request(DataGridExtractorId::Raw);
|
|
request.columns = vec![column("name", 0)];
|
|
request.selected_column_indexes = vec![0];
|
|
request.rows = vec![vec![Value::Null]];
|
|
|
|
let result = extract_data_grid_selection(request).expect("raw extraction");
|
|
|
|
assert_eq!(result.text, "");
|
|
}
|
|
|
|
#[test]
|
|
fn raw_rejects_multiple_selected_cells() {
|
|
let error =
|
|
extract_data_grid_selection(request(DataGridExtractorId::Raw)).expect_err("raw must reject multiple cells");
|
|
|
|
assert_eq!(error.code, DataGridExtractErrorCode::InvalidRawSelection);
|
|
}
|
|
|
|
#[test]
|
|
fn csv_distinguishes_null_from_null_string() {
|
|
let mut request = request(DataGridExtractorId::Csv);
|
|
request.rows = vec![vec![json!(1), Value::Null], vec![json!(2), json!("NULL")]];
|
|
let result = extract_data_grid_selection(request).expect("CSV extraction");
|
|
// NULL emits the bare sentinel; the literal string "NULL" is force-quoted.
|
|
assert_eq!(result.text, "1,NULL\n2,\"NULL\"");
|
|
}
|
|
|
|
#[test]
|
|
fn csv_keeps_null_unquoted_under_always_quote() {
|
|
let mut request = request(DataGridExtractorId::Csv);
|
|
request.rows = vec![vec![json!(1), Value::Null], vec![json!(2), json!("NULL")]];
|
|
request.options.dsv.quote_policy = DataGridQuotePolicy::Always;
|
|
let result = extract_data_grid_selection(request).expect("CSV extraction");
|
|
// NULL stays bare even under Always; the string is quoted, so they differ.
|
|
assert_eq!(result.text, "\"1\",NULL\n\"2\",\"NULL\"");
|
|
}
|
|
|
|
#[test]
|
|
fn csv_null_and_sentinel_collapse_under_never_quote() {
|
|
let mut request = request(DataGridExtractorId::Csv);
|
|
request.rows = vec![vec![json!(1), Value::Null], vec![json!(2), json!("NULL")]];
|
|
request.options.dsv.quote_policy = DataGridQuotePolicy::Never;
|
|
let result = extract_data_grid_selection(request).expect("CSV extraction");
|
|
// Under Never quoting, NULL and the string "NULL" are inherently indistinguishable.
|
|
assert_eq!(result.text, "1,NULL\n2,NULL");
|
|
}
|
|
|
|
#[test]
|
|
fn csv_empty_null_text_distinguishes_empty_string() {
|
|
let mut request = request(DataGridExtractorId::Csv);
|
|
request.rows = vec![vec![json!(1), Value::Null], vec![json!(2), json!("")]];
|
|
request.options.dsv.null_text = String::new();
|
|
let result = extract_data_grid_selection(request).expect("CSV extraction");
|
|
// NULL -> bare empty; the empty string is force-quoted.
|
|
assert_eq!(result.text, "1,\n2,\"\"");
|
|
}
|
|
|
|
#[test]
|
|
fn one_row_distinguishes_null_from_null_string() {
|
|
let mut request = request(DataGridExtractorId::OneRow);
|
|
request.rows = vec![vec![json!(1), Value::Null], vec![json!(2), json!("NULL")]];
|
|
let result = extract_data_grid_selection(request).expect("one-row extraction");
|
|
assert_eq!(result.text, "1,NULL,2,\"NULL\"");
|
|
}
|
|
|
|
#[test]
|
|
fn extracts_one_row_as_a_single_csv_record() {
|
|
let result = extract_data_grid_selection(request(DataGridExtractorId::OneRow)).expect("One-row extraction");
|
|
assert_eq!(result.text, "1,Ada,2,\"Grace, Hopper\"");
|
|
}
|
|
|
|
#[test]
|
|
fn extracts_all_remaining_text_table_formats() {
|
|
let cases = [
|
|
(DataGridExtractorId::Tsv, "1\tAda\n2\tGrace, Hopper"),
|
|
(DataGridExtractorId::TsvWithHeaders, "id\tname\n1\tAda\n2\tGrace, Hopper"),
|
|
(DataGridExtractorId::CsvWithHeaders, "id,name\n1,Ada\n2,\"Grace, Hopper\""),
|
|
(DataGridExtractorId::PipeSeparated, "1|Ada\n2|Grace, Hopper"),
|
|
(
|
|
DataGridExtractorId::Markdown,
|
|
"| id | name |\n| --- | --- |\n| 1 | Ada |\n| 2 | Grace, Hopper |",
|
|
),
|
|
(
|
|
DataGridExtractorId::Pretty,
|
|
"+----+---------------+\n| id | name |\n+----+---------------+\n| 1 | Ada |\n| 2 | Grace, Hopper |\n+----+---------------+\n",
|
|
),
|
|
];
|
|
|
|
for (extractor, expected) in cases {
|
|
let result = extract_data_grid_selection(request(extractor)).expect("text table extraction");
|
|
assert_eq!(result.text, expected, "unexpected output for {extractor:?}");
|
|
assert_eq!(result.row_count, 2);
|
|
assert_eq!(result.column_count, 2);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn pretty_output_uses_terminal_width_for_cjk_and_emoji() {
|
|
let mut request = request(DataGridExtractorId::Pretty);
|
|
request.columns = vec![column("标签", 0), column("name", 1)];
|
|
request.rows = vec![vec![json!("中文"), json!("🙂")]];
|
|
|
|
let result = extract_data_grid_selection(request).expect("Unicode pretty extraction");
|
|
|
|
assert_eq!(
|
|
result.text,
|
|
"+------+------+
|
|
| 标签 | name |
|
|
+------+------+
|
|
| 中文 | 🙂 |
|
|
+------+------+
|
|
"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn one_row_honors_standard_csv_quote_configuration() {
|
|
let mut request = request(DataGridExtractorId::OneRow);
|
|
request.options.dsv.quote_policy = DataGridQuotePolicy::Always;
|
|
request.options.dsv.quote = '\'';
|
|
|
|
let result = extract_data_grid_selection(request).expect("configured One-row extraction");
|
|
|
|
assert_eq!(result.text, "'1','Ada','2','Grace, Hopper'");
|
|
}
|
|
|
|
#[test]
|
|
fn extracts_multi_column_sql_in_as_row_value_tuples() {
|
|
let result = extract_data_grid_selection(request(DataGridExtractorId::SqlInList)).expect("SQL IN extraction");
|
|
assert_eq!(result.text, "((1, 'Ada'), (2, 'Grace, Hopper'))");
|
|
}
|
|
|
|
#[test]
|
|
fn sql_in_list_deduplicates_single_selected_values() {
|
|
let mut request = request(DataGridExtractorId::SqlInList);
|
|
request.selected_column_indexes = vec![0];
|
|
request.rows = vec![
|
|
vec![json!(1), json!("first")],
|
|
vec![json!(1), json!("unselected value differs")],
|
|
vec![json!(2), json!("last")],
|
|
];
|
|
|
|
let result = extract_data_grid_selection(request).expect("SQL IN extraction");
|
|
|
|
assert_eq!(result.text, "(1, 2)");
|
|
}
|
|
|
|
#[test]
|
|
fn sql_in_list_deduplicates_multi_column_tuples_in_first_seen_order() {
|
|
let mut request = request(DataGridExtractorId::SqlInList);
|
|
request.rows = vec![
|
|
vec![json!(2), json!("Grace")],
|
|
vec![json!(1), json!("Ada")],
|
|
vec![json!(2), json!("Grace")],
|
|
vec![json!(1), json!("Lovelace")],
|
|
vec![json!(1), json!("Ada")],
|
|
];
|
|
|
|
let result = extract_data_grid_selection(request).expect("SQL IN extraction");
|
|
|
|
assert_eq!(result.text, "((2, 'Grace'), (1, 'Ada'), (1, 'Lovelace'))");
|
|
}
|
|
|
|
#[test]
|
|
fn sql_in_list_deduplicates_only_identical_rendered_literals() {
|
|
let mut request = request(DataGridExtractorId::SqlInList);
|
|
request.selected_column_indexes = vec![0];
|
|
request.rows = vec![
|
|
vec![json!(1)],
|
|
vec![json!("1")],
|
|
vec![Value::Null],
|
|
vec![Value::Null],
|
|
vec![json!("O'Reilly")],
|
|
vec![json!("O'Reilly")],
|
|
];
|
|
|
|
let result = extract_data_grid_selection(request).expect("SQL IN extraction");
|
|
|
|
assert_eq!(result.text, "(1, '1', NULL, 'O''Reilly')");
|
|
}
|
|
|
|
#[test]
|
|
fn sql_in_list_honors_kingbase_bit_literals() {
|
|
let mut request = request(DataGridExtractorId::SqlInList);
|
|
request.database_type = Some(DatabaseType::Kingbase);
|
|
request.identifier_quote = Some("`".to_string());
|
|
request.columns = vec![column("flag", 0)];
|
|
request.selected_column_indexes = vec![0];
|
|
request.table_meta = Some(DataGridTableMeta {
|
|
catalog: None,
|
|
database: None,
|
|
schema: None,
|
|
table_name: "flags".to_string(),
|
|
primary_keys: vec![],
|
|
columns: Some(vec![DataGridColumnInfo {
|
|
name: "flag".to_string(),
|
|
data_type: "pg_catalog.bit(1)".to_string(),
|
|
is_nullable: true,
|
|
is_primary_key: false,
|
|
column_default: None,
|
|
extra: None,
|
|
}]),
|
|
});
|
|
request.rows = vec![vec![json!("0")], vec![json!("1")]];
|
|
|
|
let result = extract_data_grid_selection(request).expect("Kingbase SQL IN extraction");
|
|
assert_eq!(result.text, "(b'0', b'1')");
|
|
}
|
|
|
|
#[test]
|
|
fn preserves_duplicate_json_columns_without_overwriting_values() {
|
|
let mut request = request(DataGridExtractorId::Json);
|
|
request.columns[1].display_name = "id".to_string();
|
|
let result = extract_data_grid_selection(request).expect("JSON extraction");
|
|
assert!(result.text.contains("\"id_2\""));
|
|
assert_eq!(result.warnings.len(), 1);
|
|
}
|
|
|
|
#[test]
|
|
fn avoids_collisions_between_generated_and_existing_json_column_suffixes() {
|
|
let mut request = request(DataGridExtractorId::Json);
|
|
request.columns = vec![column("id", 0), column("id", 1), column("id_2", 2)];
|
|
request.selected_column_indexes = vec![0, 1, 2];
|
|
request.rows = vec![vec![json!(1), json!(2), json!(3)]];
|
|
|
|
let result = extract_data_grid_selection(request).expect("JSON extraction");
|
|
let rows = serde_json::from_str::<Value>(&result.text).expect("valid JSON output");
|
|
|
|
assert_eq!(rows, json!([{"id": 1, "id_3": 2, "id_2": 3}]));
|
|
assert_eq!(result.warnings.len(), 1);
|
|
}
|
|
|
|
#[test]
|
|
fn builds_updates_with_hidden_primary_keys_and_selected_columns() {
|
|
let mut request = request(DataGridExtractorId::SqlUpdates);
|
|
request.table_meta = Some(DataGridTableMeta {
|
|
catalog: None,
|
|
database: None,
|
|
schema: Some("public".to_string()),
|
|
table_name: "users".to_string(),
|
|
primary_keys: vec!["id".to_string()],
|
|
columns: Some(vec![
|
|
DataGridColumnInfo {
|
|
name: "id".to_string(),
|
|
data_type: "int".to_string(),
|
|
is_nullable: false,
|
|
is_primary_key: true,
|
|
column_default: None,
|
|
extra: None,
|
|
},
|
|
DataGridColumnInfo {
|
|
name: "name".to_string(),
|
|
data_type: "varchar".to_string(),
|
|
is_nullable: false,
|
|
is_primary_key: false,
|
|
column_default: None,
|
|
extra: None,
|
|
},
|
|
]),
|
|
});
|
|
request.selected_column_indexes = vec![1];
|
|
let result = extract_data_grid_selection(request).expect("SQL Updates extraction");
|
|
assert_eq!(
|
|
result.text,
|
|
"UPDATE \"public\".\"users\" SET \"name\" = 'Ada' WHERE \"id\" = 1;\nUPDATE \"public\".\"users\" SET \"name\" = 'Grace, Hopper' WHERE \"id\" = 2;"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn sql_copy_honors_kingbase_mysql_compat_connection_identifier_quote() {
|
|
let table_meta = DataGridTableMeta {
|
|
catalog: None,
|
|
database: None,
|
|
schema: Some("audit-schema".to_string()),
|
|
table_name: "events".to_string(),
|
|
primary_keys: vec!["id".to_string()],
|
|
columns: Some(vec![
|
|
DataGridColumnInfo {
|
|
name: "id".to_string(),
|
|
data_type: "int".to_string(),
|
|
is_nullable: false,
|
|
is_primary_key: true,
|
|
column_default: None,
|
|
extra: None,
|
|
},
|
|
DataGridColumnInfo {
|
|
name: "event_type".to_string(),
|
|
data_type: "varchar".to_string(),
|
|
is_nullable: false,
|
|
is_primary_key: false,
|
|
column_default: None,
|
|
extra: None,
|
|
},
|
|
]),
|
|
};
|
|
|
|
let mut insert = request(DataGridExtractorId::SqlInserts);
|
|
insert.database_type = Some(DatabaseType::Kingbase);
|
|
insert.identifier_quote = Some("`".to_string());
|
|
insert.table_meta = Some(table_meta.clone());
|
|
insert.columns = vec![column("id", 0), column("event_type", 1)];
|
|
insert.rows = vec![vec![json!(1), json!("login")]];
|
|
let insert_result = extract_data_grid_selection(insert).expect("Kingbase SQL INSERT extraction");
|
|
assert_eq!(insert_result.text, "INSERT INTO `audit-schema`.`events` (`id`, `event_type`) VALUES (1, 'login');");
|
|
|
|
let mut updates = request(DataGridExtractorId::SqlUpdates);
|
|
updates.database_type = Some(DatabaseType::Kingbase);
|
|
updates.identifier_quote = Some("`".to_string());
|
|
updates.table_meta = Some(table_meta);
|
|
updates.columns = vec![column("id", 0), column("event_type", 1)];
|
|
updates.rows = vec![vec![json!(1), json!("logout")]];
|
|
let updates_result = extract_data_grid_selection(updates).expect("Kingbase SQL UPDATE extraction");
|
|
assert_eq!(updates_result.text, "UPDATE `audit-schema`.`events` SET `event_type` = 'logout' WHERE `id` = 1;");
|
|
}
|
|
|
|
#[test]
|
|
fn sql_update_computed_column_option_matches_the_frontend_capability() {
|
|
let mut request = request(DataGridExtractorId::SqlUpdates);
|
|
request.columns[1].display_name = "search_text".to_string();
|
|
request.columns[1].source_name = Some("search_text".to_string());
|
|
request.selected_column_indexes = vec![1];
|
|
request.table_meta = Some(DataGridTableMeta {
|
|
catalog: None,
|
|
database: None,
|
|
schema: None,
|
|
table_name: "users".to_string(),
|
|
primary_keys: vec!["id".to_string()],
|
|
columns: Some(vec![
|
|
DataGridColumnInfo {
|
|
name: "id".to_string(),
|
|
data_type: "int".to_string(),
|
|
is_nullable: false,
|
|
is_primary_key: true,
|
|
column_default: None,
|
|
extra: None,
|
|
},
|
|
DataGridColumnInfo {
|
|
name: "search_text".to_string(),
|
|
data_type: "text".to_string(),
|
|
is_nullable: true,
|
|
is_primary_key: false,
|
|
column_default: None,
|
|
extra: Some("GENERATED ALWAYS AS".to_string()),
|
|
},
|
|
]),
|
|
});
|
|
|
|
let skipped = extract_data_grid_selection(request.clone()).expect_err("computed UPDATE is skipped by default");
|
|
assert_eq!(skipped.code, DataGridExtractErrorCode::NoWritableColumns);
|
|
|
|
request.options.sql.skip_computed_columns = false;
|
|
let included = extract_data_grid_selection(request).expect("explicit computed UPDATE extraction");
|
|
assert!(included.text.contains("SET \"search_text\" ="));
|
|
}
|
|
|
|
#[test]
|
|
fn rejects_null_primary_keys_fail_fast() {
|
|
let mut request = request(DataGridExtractorId::SqlUpdates);
|
|
request.rows[0][0] = Value::Null;
|
|
request.selected_column_indexes = vec![1];
|
|
request.table_meta = Some(DataGridTableMeta {
|
|
catalog: None,
|
|
database: None,
|
|
schema: None,
|
|
table_name: "users".to_string(),
|
|
primary_keys: vec!["id".to_string()],
|
|
columns: None,
|
|
});
|
|
let error = extract_data_grid_selection(request).expect_err("NULL primary key must fail");
|
|
assert_eq!(error.code, DataGridExtractErrorCode::NullPrimaryKey);
|
|
}
|
|
|
|
#[test]
|
|
fn extracts_custom_dsv_with_headers_nulls_and_standard_escaping() {
|
|
let mut request = request(DataGridExtractorId::Dsv);
|
|
request.rows[0][0] = Value::Null;
|
|
request.rows[0][1] = json!("Ada;Lovelace");
|
|
request.options.dsv = DataGridDsvOptions {
|
|
column_separator: ";".to_string(),
|
|
include_column_header: true,
|
|
..DataGridDsvOptions::default()
|
|
};
|
|
let result = extract_data_grid_selection(request).expect("custom DSV extraction");
|
|
assert_eq!(result.text, "id;name\nNULL;\"Ada;Lovelace\"\n2;Grace, Hopper");
|
|
}
|
|
|
|
#[test]
|
|
fn custom_dsv_honors_row_headers_and_quote_policy() {
|
|
let mut request = request(DataGridExtractorId::Dsv);
|
|
request.options.dsv = DataGridDsvOptions {
|
|
column_separator: ";".to_string(),
|
|
include_row_header: true,
|
|
quote_policy: DataGridQuotePolicy::Always,
|
|
..DataGridDsvOptions::default()
|
|
};
|
|
|
|
let result = extract_data_grid_selection(request).expect("configured DSV extraction");
|
|
|
|
assert_eq!(result.text, "\"1\";\"1\";\"Ada\"\n\"2\";\"2\";\"Grace, Hopper\"");
|
|
}
|
|
|
|
#[test]
|
|
fn extracts_json_lines_as_one_object_per_record() {
|
|
let result = extract_data_grid_selection(request(DataGridExtractorId::JsonLines)).expect("JSON Lines extraction");
|
|
assert_eq!(result.text.lines().count(), 2);
|
|
let first_row =
|
|
serde_json::from_str::<Value>(result.text.lines().next().unwrap_or_default()).expect("first JSON Lines record");
|
|
assert_eq!(first_row, json!({"id": 1, "name": "Ada"}));
|
|
}
|
|
|
|
#[test]
|
|
fn extracts_compact_json_when_pretty_printing_is_disabled() {
|
|
let mut request = request(DataGridExtractorId::Json);
|
|
request.options.json.pretty = false;
|
|
|
|
let result = extract_data_grid_selection(request).expect("compact JSON extraction");
|
|
|
|
assert_eq!(result.text, "[{\"id\":1,\"name\":\"Ada\"},{\"id\":2,\"name\":\"Grace, Hopper\"}]");
|
|
}
|
|
|
|
#[test]
|
|
fn converts_snake_case_json_field_names_only_when_enabled() {
|
|
let mut request = request(DataGridExtractorId::Json);
|
|
request.columns = vec![
|
|
column("ID", 0),
|
|
column("CODE", 1),
|
|
column("NAME", 2),
|
|
column("CREATE_TIME", 3),
|
|
column("user_id", 4),
|
|
column("ORDER_ITEM_ID", 5),
|
|
column("alreadyCamel", 6),
|
|
column("_display__name_", 7),
|
|
column("naïve_value", 8),
|
|
];
|
|
request.selected_column_indexes = vec![0, 1, 2, 3, 4, 5, 6, 7, 8];
|
|
request.rows = vec![vec![
|
|
json!(1),
|
|
json!("A01"),
|
|
json!("Ada"),
|
|
json!("2026-08-16T08:52:23Z"),
|
|
json!(7),
|
|
json!(9),
|
|
json!("kept"),
|
|
json!("Ada"),
|
|
json!(true),
|
|
]];
|
|
|
|
let unchanged = extract_data_grid_selection(request.clone()).expect("default JSON extraction");
|
|
assert_eq!(
|
|
serde_json::from_str::<Value>(&unchanged.text).expect("valid default JSON"),
|
|
json!([{
|
|
"ID": 1,
|
|
"CODE": "A01",
|
|
"NAME": "Ada",
|
|
"CREATE_TIME": "2026-08-16T08:52:23Z",
|
|
"user_id": 7,
|
|
"ORDER_ITEM_ID": 9,
|
|
"alreadyCamel": "kept",
|
|
"_display__name_": "Ada",
|
|
"naïve_value": true
|
|
}])
|
|
);
|
|
|
|
request.options.json.camel_case_field_names = true;
|
|
let converted = extract_data_grid_selection(request).expect("camel-case JSON extraction");
|
|
assert_eq!(
|
|
serde_json::from_str::<Value>(&converted.text).expect("valid converted JSON"),
|
|
json!([{
|
|
"id": 1,
|
|
"code": "A01",
|
|
"name": "Ada",
|
|
"createTime": "2026-08-16T08:52:23Z",
|
|
"userId": 7,
|
|
"orderItemId": 9,
|
|
"alreadyCamel": "kept",
|
|
"displayName": "Ada",
|
|
"naïveValue": true
|
|
}])
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn converts_json_lines_names_and_suffixes_post_conversion_collisions() {
|
|
let mut request = request(DataGridExtractorId::JsonLines);
|
|
request.columns = vec![column("user_id", 0), column("userId", 1), column("___", 2)];
|
|
request.selected_column_indexes = vec![0, 1, 2];
|
|
request.rows = vec![vec![json!(1), json!(2), json!(3)], vec![json!(4), json!(5), json!(6)]];
|
|
request.options.json.camel_case_field_names = true;
|
|
|
|
let result = extract_data_grid_selection(request).expect("camel-case JSON Lines extraction");
|
|
let rows = result
|
|
.text
|
|
.lines()
|
|
.map(|line| serde_json::from_str::<Value>(line).expect("valid JSON Lines record"))
|
|
.collect::<Vec<_>>();
|
|
|
|
assert_eq!(
|
|
rows,
|
|
vec![json!({"userId": 1, "userId_2": 2, "___": 3}), json!({"userId": 4, "userId_2": 5, "___": 6})]
|
|
);
|
|
assert_eq!(result.warnings.len(), 1);
|
|
assert_eq!(result.warnings[0].code, DataGridExtractWarningCode::DuplicateJsonColumnNames);
|
|
}
|
|
|
|
#[test]
|
|
fn suffixes_collisions_after_normalizing_uppercase_json_names() {
|
|
let mut request = request(DataGridExtractorId::Json);
|
|
request.columns = vec![column("ID", 0), column("id", 1)];
|
|
request.selected_column_indexes = vec![0, 1];
|
|
request.rows = vec![vec![json!(1), json!(2)]];
|
|
request.options.json.camel_case_field_names = true;
|
|
|
|
let result = extract_data_grid_selection(request).expect("normalized JSON extraction");
|
|
|
|
assert_eq!(serde_json::from_str::<Value>(&result.text).expect("valid JSON"), json!([{"id": 1, "id_2": 2}]));
|
|
assert_eq!(result.warnings.len(), 1);
|
|
assert_eq!(result.warnings[0].code, DataGridExtractWarningCode::DuplicateJsonColumnNames);
|
|
}
|
|
|
|
#[test]
|
|
fn builds_null_safe_where_clause_predicates() {
|
|
let mut request = request(DataGridExtractorId::WhereClause);
|
|
request.selected_column_indexes = vec![1];
|
|
request.rows = vec![vec![json!(1), Value::Null]];
|
|
let result = extract_data_grid_selection(request).expect("WHERE extraction");
|
|
assert_eq!(result.text, "\"name\" IS NULL");
|
|
}
|
|
|
|
#[test]
|
|
fn builds_select_for_one_explicit_cell() {
|
|
let mut request = request(DataGridExtractorId::SqlSelect);
|
|
request.table_meta = Some(DataGridTableMeta {
|
|
catalog: None,
|
|
database: None,
|
|
schema: Some("public".to_string()),
|
|
table_name: "users".to_string(),
|
|
primary_keys: vec!["id".to_string()],
|
|
columns: None,
|
|
});
|
|
request.selected_column_indexes = vec![1];
|
|
request.rows = vec![vec![json!(7), json!("Ada")]];
|
|
|
|
let result = extract_data_grid_selection(request).expect("SELECT extraction");
|
|
|
|
assert_eq!(result.text, "SELECT * FROM \"public\".\"users\" WHERE \"name\" = 'Ada';");
|
|
}
|
|
|
|
#[test]
|
|
fn select_row_uses_complete_identity_including_hidden_columns() {
|
|
let mut request = request(DataGridExtractorId::SqlSelect);
|
|
request.table_meta = Some(DataGridTableMeta {
|
|
catalog: None,
|
|
database: None,
|
|
schema: None,
|
|
table_name: "users".to_string(),
|
|
primary_keys: vec!["tenant_id".to_string(), "id".to_string()],
|
|
columns: None,
|
|
});
|
|
request.columns = vec![column("name", 0), column("id", 1), column("tenant_id", 2)];
|
|
request.selected_column_indexes = vec![0];
|
|
request.rows = vec![vec![json!("Ada"), json!(7), json!(9)]];
|
|
request.selection_kind = DataGridSelectionKind::Rows;
|
|
|
|
let result = extract_data_grid_selection(request).expect("SELECT extraction");
|
|
|
|
assert_eq!(result.text, "SELECT * FROM \"users\" WHERE \"tenant_id\" = 9 AND \"id\" = 7;");
|
|
}
|
|
|
|
#[test]
|
|
fn select_row_falls_back_to_all_columns_without_usable_identity() {
|
|
for primary_keys in [Vec::new(), vec!["id".to_string()]] {
|
|
let mut request = request(DataGridExtractorId::SqlSelect);
|
|
request.table_meta = Some(DataGridTableMeta {
|
|
catalog: None,
|
|
database: None,
|
|
schema: None,
|
|
table_name: "users".to_string(),
|
|
primary_keys,
|
|
columns: None,
|
|
});
|
|
request.rows = vec![vec![Value::Null, json!("Ada")]];
|
|
request.selection_kind = DataGridSelectionKind::Rows;
|
|
|
|
let result = extract_data_grid_selection(request).expect("SELECT extraction");
|
|
|
|
assert_eq!(result.text, "SELECT * FROM \"users\" WHERE \"id\" IS NULL AND \"name\" = 'Ada';");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn select_cells_joins_multiple_columns_and_rows() {
|
|
// A genuine multi-cell selection (same-row columns AND'd, multi-row
|
|
// selections OR'd) is allowed for SELECT and reuses the WHERE predicate
|
|
// builder, matching "Copy as WHERE clause" for the same selection.
|
|
let mut request = request(DataGridExtractorId::SqlSelect);
|
|
request.table_meta = Some(DataGridTableMeta {
|
|
catalog: None,
|
|
database: None,
|
|
schema: None,
|
|
table_name: "users".to_string(),
|
|
primary_keys: vec!["id".to_string()],
|
|
columns: None,
|
|
});
|
|
|
|
let result = extract_data_grid_selection(request).expect("multi-cell SELECT extraction");
|
|
|
|
assert_eq!(result.text, "SELECT * FROM \"users\" WHERE (\"id\" = 1 AND \"name\" = 'Ada') OR (\"id\" = 2 AND \"name\" = 'Grace, Hopper');");
|
|
}
|
|
|
|
#[test]
|
|
fn select_rejects_ambiguous_selection_and_missing_target() {
|
|
let error = extract_data_grid_selection(request(DataGridExtractorId::SqlSelect))
|
|
.expect_err("cells without a table must fail");
|
|
assert_eq!(error.code, DataGridExtractErrorCode::MissingTableMetadata);
|
|
|
|
let mut request = request(DataGridExtractorId::SqlSelect);
|
|
request.table_meta = Some(DataGridTableMeta {
|
|
catalog: None,
|
|
database: None,
|
|
schema: None,
|
|
table_name: "users".to_string(),
|
|
primary_keys: Vec::new(),
|
|
columns: None,
|
|
});
|
|
request.selection_kind = DataGridSelectionKind::Columns;
|
|
let error = extract_data_grid_selection(request.clone()).expect_err("column selection must fail");
|
|
assert_eq!(error.code, DataGridExtractErrorCode::InvalidSelectSelection);
|
|
|
|
request.selection_kind = DataGridSelectionKind::Rows;
|
|
let error = extract_data_grid_selection(request).expect_err("multiple selected rows must fail");
|
|
assert_eq!(error.code, DataGridExtractErrorCode::InvalidSelectSelection);
|
|
}
|
|
|
|
#[test]
|
|
fn where_clause_applies_mysql_json_cast() {
|
|
// WHERE must reuse the UPDATE predicate builder so MySQL JSON columns get
|
|
// CAST(... AS JSON) instead of a raw string literal.
|
|
let mut request = request(DataGridExtractorId::WhereClause);
|
|
request.database_type = Some(DatabaseType::Mysql);
|
|
request.selected_column_indexes = vec![1];
|
|
request.rows = vec![vec![json!(1), json!("{\"k\":1}")]];
|
|
request.table_meta = Some(DataGridTableMeta {
|
|
catalog: None,
|
|
database: None,
|
|
schema: None,
|
|
table_name: "t".to_string(),
|
|
primary_keys: vec!["id".to_string()],
|
|
columns: Some(vec![
|
|
DataGridColumnInfo {
|
|
name: "id".to_string(),
|
|
data_type: "int".to_string(),
|
|
is_nullable: false,
|
|
is_primary_key: true,
|
|
column_default: None,
|
|
extra: None,
|
|
},
|
|
DataGridColumnInfo {
|
|
name: "name".to_string(),
|
|
data_type: "json".to_string(),
|
|
is_nullable: true,
|
|
is_primary_key: false,
|
|
column_default: None,
|
|
extra: None,
|
|
},
|
|
]),
|
|
});
|
|
let mut select_request = request.clone();
|
|
select_request.extractor = DataGridExtractorId::SqlSelect;
|
|
let result = extract_data_grid_selection(request).expect("WHERE extraction");
|
|
assert!(
|
|
result.text.contains("CAST(") && result.text.contains(" AS JSON)"),
|
|
"expected MySQL JSON CAST predicate, got: {}",
|
|
result.text
|
|
);
|
|
|
|
let select_result = extract_data_grid_selection(select_request).expect("SELECT extraction");
|
|
assert!(
|
|
select_result.text.starts_with("SELECT * FROM `t` WHERE ")
|
|
&& select_result.text.contains("CAST(")
|
|
&& select_result.text.contains(" AS JSON)"),
|
|
"expected MySQL JSON CAST predicate in SELECT, got: {}",
|
|
select_result.text
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn select_cells_falls_back_to_display_name_like_where_clause() {
|
|
// SELECT built from a cell selection reuses write_where_clause, so a
|
|
// missing source_name must fall back to display_name exactly like WHERE
|
|
// does, instead of erroring — the two must stay in lockstep for the
|
|
// identical selection.
|
|
let mut request = request(DataGridExtractorId::SqlSelect);
|
|
request.table_meta = Some(DataGridTableMeta {
|
|
catalog: None,
|
|
database: None,
|
|
schema: None,
|
|
table_name: "users".to_string(),
|
|
primary_keys: vec!["id".to_string()],
|
|
columns: None,
|
|
});
|
|
request.columns = vec![
|
|
DataGridExtractColumn { display_name: "id".to_string(), source_name: None, source_index: 0 },
|
|
column("name", 1),
|
|
];
|
|
let mut where_request = request.clone();
|
|
where_request.extractor = DataGridExtractorId::WhereClause;
|
|
|
|
let result = extract_data_grid_selection(request).expect("SELECT extraction with missing source_name");
|
|
assert_eq!(
|
|
result.text,
|
|
"SELECT * FROM \"users\" WHERE (\"id\" = 1 AND \"name\" = 'Ada') OR (\"id\" = 2 AND \"name\" = 'Grace, Hopper');"
|
|
);
|
|
|
|
let where_result = extract_data_grid_selection(where_request).expect("WHERE extraction with missing source_name");
|
|
assert_eq!(where_result.text, "(\"id\" = 1 AND \"name\" = 'Ada') OR (\"id\" = 2 AND \"name\" = 'Grace, Hopper')");
|
|
}
|
|
|
|
#[test]
|
|
fn where_clause_rejects_unsupported_nosql_databases() {
|
|
for database_type in [DatabaseType::MongoDb, DatabaseType::Neo4j, DatabaseType::Tdengine] {
|
|
let mut request = request(DataGridExtractorId::WhereClause);
|
|
request.database_type = Some(database_type);
|
|
let error = extract_data_grid_selection(request).expect_err("WHERE must reject NoSQL");
|
|
assert_eq!(error.code, DataGridExtractErrorCode::UnsupportedDatabase, "{database_type:?}");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn build_data_grid_copy_update_statements_returns_empty_for_mongodb() {
|
|
use crate::data_grid_sql::{build_data_grid_copy_update_statements, DataGridCopyUpdateStatementOptions};
|
|
let options = DataGridCopyUpdateStatementOptions {
|
|
database_type: Some(DatabaseType::MongoDb),
|
|
identifier_quote: None,
|
|
table_meta: DataGridTableMeta {
|
|
catalog: None,
|
|
database: None,
|
|
schema: None,
|
|
table_name: "t".to_string(),
|
|
primary_keys: vec!["id".to_string()],
|
|
columns: None,
|
|
},
|
|
columns: vec!["id".to_string()],
|
|
source_columns: Some(vec![Some("id".to_string())]),
|
|
rows: vec![vec![json!(1)]],
|
|
include_database_name: false,
|
|
};
|
|
assert!(build_data_grid_copy_update_statements(options).is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn format_grid_sql_literal_uses_numeric_bool_for_sqlserver() {
|
|
use crate::data_grid_sql::format_grid_sql_literal;
|
|
let column = DataGridColumnInfo {
|
|
name: "active".to_string(),
|
|
data_type: "tinyint".to_string(),
|
|
is_nullable: true,
|
|
is_primary_key: false,
|
|
column_default: None,
|
|
extra: None,
|
|
};
|
|
// SQL Server has no TRUE/FALSE literals; emit 1/0 even for non-BIT columns.
|
|
assert_eq!(format_grid_sql_literal(&json!(true), Some(DatabaseType::SqlServer), Some(&column)), "1");
|
|
assert_eq!(format_grid_sql_literal(&json!(false), Some(DatabaseType::SqlServer), Some(&column)), "0");
|
|
// Other dialects still emit TRUE/FALSE for non-bit columns.
|
|
assert_eq!(format_grid_sql_literal(&json!(true), Some(DatabaseType::Postgres), Some(&column)), "TRUE");
|
|
}
|
|
|
|
#[test]
|
|
fn escapes_html_and_preserves_xml_null_semantics() {
|
|
let mut html_request = request(DataGridExtractorId::Html);
|
|
html_request.rows = vec![vec![json!(1), json!("<Ada & Grace>")]];
|
|
let html = extract_data_grid_selection(html_request).expect("HTML extraction");
|
|
assert!(html.text.contains("<Ada & Grace>"));
|
|
|
|
let mut xml_request = request(DataGridExtractorId::Xml);
|
|
xml_request.rows = vec![vec![json!(1), Value::Null]];
|
|
let xml = extract_data_grid_selection(xml_request).expect("XML extraction");
|
|
assert!(xml.text.contains("name=\"name\" null=\"true\""));
|
|
}
|
|
|
|
#[test]
|
|
fn sql_insert_skips_generated_and_computed_columns() {
|
|
let mut request = request(DataGridExtractorId::SqlInserts);
|
|
request.columns.push(column("search_text", 2));
|
|
request.selected_column_indexes = vec![0, 1, 2];
|
|
request.rows = vec![vec![json!(7), json!("Ada"), json!("generated")]];
|
|
request.table_meta = Some(DataGridTableMeta {
|
|
catalog: None,
|
|
database: None,
|
|
schema: None,
|
|
table_name: "users".to_string(),
|
|
primary_keys: vec!["id".to_string()],
|
|
columns: Some(vec![
|
|
DataGridColumnInfo {
|
|
name: "id".to_string(),
|
|
data_type: "int".to_string(),
|
|
is_nullable: false,
|
|
is_primary_key: true,
|
|
column_default: None,
|
|
extra: Some("auto_increment".to_string()),
|
|
},
|
|
DataGridColumnInfo {
|
|
name: "name".to_string(),
|
|
data_type: "varchar".to_string(),
|
|
is_nullable: false,
|
|
is_primary_key: false,
|
|
column_default: None,
|
|
extra: None,
|
|
},
|
|
DataGridColumnInfo {
|
|
name: "search_text".to_string(),
|
|
data_type: "text".to_string(),
|
|
is_nullable: true,
|
|
is_primary_key: false,
|
|
column_default: None,
|
|
extra: Some("GENERATED ALWAYS AS".to_string()),
|
|
},
|
|
]),
|
|
});
|
|
let mut include_computed_request = request.clone();
|
|
include_computed_request.options.sql.skip_computed_columns = false;
|
|
let mut include_generated_request = request.clone();
|
|
include_generated_request.options.sql.skip_generated_columns = false;
|
|
|
|
let result = extract_data_grid_selection(request).expect("SQL INSERT extraction");
|
|
assert!(result.text.contains("name"));
|
|
assert!(!result.text.contains("search_text"));
|
|
assert!(result.text.contains("(\"id\", \"name\")"));
|
|
assert_eq!(result.omitted_columns, vec!["search_text"]);
|
|
|
|
let included =
|
|
extract_data_grid_selection(include_computed_request).expect("SQL INSERT extraction with computed columns");
|
|
assert!(included.text.contains("search_text"));
|
|
assert!(included.omitted_columns.is_empty());
|
|
|
|
let included =
|
|
extract_data_grid_selection(include_generated_request).expect("SQL INSERT extraction with generated columns");
|
|
assert!(included.text.contains("(\"id\", \"name\")"));
|
|
assert_eq!(included.omitted_columns, vec!["search_text"]);
|
|
}
|
|
|
|
#[test]
|
|
fn sql_insert_keeps_autoincrement_primary_key_by_default() {
|
|
let mut request = request(DataGridExtractorId::SqlInserts);
|
|
request.table_meta = Some(DataGridTableMeta {
|
|
catalog: None,
|
|
database: None,
|
|
schema: None,
|
|
table_name: "users".to_string(),
|
|
primary_keys: vec!["id".to_string()],
|
|
columns: Some(vec![
|
|
DataGridColumnInfo {
|
|
name: "id".to_string(),
|
|
data_type: "int".to_string(),
|
|
is_nullable: false,
|
|
is_primary_key: true,
|
|
column_default: None,
|
|
extra: Some("auto_increment".to_string()),
|
|
},
|
|
DataGridColumnInfo {
|
|
name: "name".to_string(),
|
|
data_type: "varchar".to_string(),
|
|
is_nullable: false,
|
|
is_primary_key: false,
|
|
column_default: None,
|
|
extra: None,
|
|
},
|
|
]),
|
|
});
|
|
|
|
let result = extract_data_grid_selection(request).expect("SQL INSERT extraction");
|
|
|
|
assert!(result.text.contains("INSERT INTO \"users\" (\"id\", \"name\")"));
|
|
assert!(result.text.contains("(1, 'Ada')"));
|
|
assert!(result.omitted_columns.is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn sql_insert_honors_primary_key_exclusion_and_row_by_row_mode() {
|
|
let mut request = request(DataGridExtractorId::SqlInserts);
|
|
request.table_meta = Some(DataGridTableMeta {
|
|
catalog: None,
|
|
database: None,
|
|
schema: Some("public".to_string()),
|
|
table_name: "users".to_string(),
|
|
primary_keys: vec!["id".to_string()],
|
|
columns: Some(vec![
|
|
DataGridColumnInfo {
|
|
name: "id".to_string(),
|
|
data_type: "bigint".to_string(),
|
|
is_nullable: false,
|
|
is_primary_key: true,
|
|
column_default: None,
|
|
extra: Some("auto_increment".to_string()),
|
|
},
|
|
DataGridColumnInfo {
|
|
name: "name".to_string(),
|
|
data_type: "text".to_string(),
|
|
is_nullable: false,
|
|
is_primary_key: false,
|
|
column_default: None,
|
|
extra: None,
|
|
},
|
|
]),
|
|
});
|
|
request.options.sql.exclude_primary_keys_from_insert = true;
|
|
request.options.sql.insert_mode = crate::data_grid_sql::DataGridCopyInsertMode::RowByRow;
|
|
|
|
let result = extract_data_grid_selection(request).expect("row-by-row SQL INSERT extraction");
|
|
|
|
assert_eq!(
|
|
result.text,
|
|
"INSERT INTO \"public\".\"users\" (\"name\") VALUES ('Ada');\nINSERT INTO \"public\".\"users\" (\"name\") VALUES ('Grace, Hopper');"
|
|
);
|
|
assert_eq!(result.omitted_columns, vec!["id"]);
|
|
}
|
|
|
|
#[test]
|
|
fn sql_insert_primary_key_exclusion_omits_postgres_serial_key() {
|
|
let mut request = request(DataGridExtractorId::SqlInserts);
|
|
request.database_type = Some(DatabaseType::Postgres);
|
|
request.table_meta = Some(DataGridTableMeta {
|
|
catalog: None,
|
|
database: None,
|
|
schema: Some("public".to_string()),
|
|
table_name: "users".to_string(),
|
|
primary_keys: vec!["id".to_string()],
|
|
columns: Some(vec![
|
|
DataGridColumnInfo {
|
|
name: "id".to_string(),
|
|
data_type: "integer".to_string(),
|
|
is_nullable: false,
|
|
is_primary_key: true,
|
|
column_default: None,
|
|
extra: Some("serial".to_string()),
|
|
},
|
|
DataGridColumnInfo {
|
|
name: "name".to_string(),
|
|
data_type: "text".to_string(),
|
|
is_nullable: false,
|
|
is_primary_key: false,
|
|
column_default: None,
|
|
extra: None,
|
|
},
|
|
]),
|
|
});
|
|
request.rows = vec![vec![json!(1), json!("Ada")]];
|
|
request.options.sql.exclude_primary_keys_from_insert = true;
|
|
|
|
let result = extract_data_grid_selection(request).expect("PostgreSQL SQL INSERT extraction");
|
|
|
|
assert_eq!(result.text, "INSERT INTO \"public\".\"users\" (\"name\") VALUES ('Ada');");
|
|
assert_eq!(result.omitted_columns, vec!["id"]);
|
|
}
|
|
|
|
#[test]
|
|
fn sql_insert_primary_key_exclusion_keeps_manual_composite_key_members() {
|
|
let mut request = request(DataGridExtractorId::SqlInserts);
|
|
request.table_meta = Some(DataGridTableMeta {
|
|
catalog: None,
|
|
database: None,
|
|
schema: None,
|
|
table_name: "daily_stats".to_string(),
|
|
primary_keys: vec!["id".to_string(), "stat_date".to_string()],
|
|
columns: Some(vec![
|
|
DataGridColumnInfo {
|
|
name: "id".to_string(),
|
|
data_type: "bigint".to_string(),
|
|
is_nullable: false,
|
|
is_primary_key: true,
|
|
column_default: None,
|
|
extra: Some("auto_increment".to_string()),
|
|
},
|
|
DataGridColumnInfo {
|
|
name: "stat_date".to_string(),
|
|
data_type: "date".to_string(),
|
|
is_nullable: false,
|
|
is_primary_key: true,
|
|
column_default: None,
|
|
extra: None,
|
|
},
|
|
DataGridColumnInfo {
|
|
name: "name".to_string(),
|
|
data_type: "text".to_string(),
|
|
is_nullable: false,
|
|
is_primary_key: false,
|
|
column_default: None,
|
|
extra: None,
|
|
},
|
|
]),
|
|
});
|
|
request.columns = vec![column("id", 0), column("stat_date", 1), column("name", 2)];
|
|
request.selected_column_indexes = vec![0, 1, 2];
|
|
request.rows = vec![vec![json!(1), json!("2026-08-18"), json!("Ada")]];
|
|
request.options.sql.exclude_primary_keys_from_insert = true;
|
|
|
|
let result = extract_data_grid_selection(request).expect("SQL INSERT extraction");
|
|
|
|
assert_eq!(result.text, "INSERT INTO \"daily_stats\" (\"stat_date\", \"name\") VALUES ('2026-08-18', 'Ada');");
|
|
assert_eq!(result.omitted_columns, vec!["id"]);
|
|
}
|
|
|
|
#[test]
|
|
fn rejects_invalid_dsv_configuration() {
|
|
let mut request = request(DataGridExtractorId::Dsv);
|
|
request.options.dsv.column_separator.clear();
|
|
let error = extract_data_grid_selection(request).expect_err("empty separator must fail");
|
|
assert_eq!(error.code, DataGridExtractErrorCode::InvalidDsvConfiguration);
|
|
}
|
|
|
|
#[test]
|
|
fn rejects_ambiguous_or_oversized_dsv_configuration() {
|
|
let mut overlapping = request(DataGridExtractorId::Dsv);
|
|
overlapping.options.dsv.column_separator = "|".to_string();
|
|
overlapping.options.dsv.row_separator = "||".to_string();
|
|
assert_eq!(
|
|
extract_data_grid_selection(overlapping).expect_err("overlapping separators must fail").code,
|
|
DataGridExtractErrorCode::InvalidDsvConfiguration
|
|
);
|
|
|
|
let mut conflicting_quote = request(DataGridExtractorId::Csv);
|
|
conflicting_quote.options.dsv.quote = ',';
|
|
assert_eq!(
|
|
extract_data_grid_selection(conflicting_quote).expect_err("separator quote must fail").code,
|
|
DataGridExtractErrorCode::InvalidDsvConfiguration
|
|
);
|
|
|
|
let mut oversized = request(DataGridExtractorId::Dsv);
|
|
oversized.options.dsv.column_separator = "123456789".to_string();
|
|
assert_eq!(
|
|
extract_data_grid_selection(oversized).expect_err("oversized separator must fail").code,
|
|
DataGridExtractErrorCode::InvalidDsvConfiguration
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn extractor_contract_uses_the_frontend_camel_case_wire_shape() {
|
|
let request = request(DataGridExtractorId::CsvWithHeaders);
|
|
let value = serde_json::to_value(&request).expect("serialize extractor request");
|
|
|
|
assert_eq!(value["extractor"], "csv-with-headers");
|
|
assert_eq!(value["databaseType"], "postgres");
|
|
assert_eq!(value["selectedColumnIndexes"], json!([0, 1]));
|
|
assert_eq!(value["selectionKind"], "cells");
|
|
assert_eq!(value["options"]["dsv"]["includeColumnHeader"], false);
|
|
assert_eq!(value["options"]["json"]["camelCaseFieldNames"], false);
|
|
assert!(value.get("selected_column_indexes").is_none());
|
|
|
|
let decoded = serde_json::from_value::<DataGridExtractRequest>(value).expect("deserialize extractor request");
|
|
assert_eq!(decoded.extractor, DataGridExtractorId::CsvWithHeaders);
|
|
assert_eq!(decoded.selected_column_indexes, vec![0, 1]);
|
|
}
|
|
|
|
#[test]
|
|
fn extractor_contract_requires_an_explicit_version() {
|
|
let mut value = serde_json::to_value(request(DataGridExtractorId::Csv)).expect("serialize extractor request");
|
|
value.as_object_mut().expect("request object").remove("version");
|
|
|
|
let error = serde_json::from_value::<DataGridExtractRequest>(value).expect_err("missing version must fail");
|
|
|
|
assert!(error.to_string().contains("version"));
|
|
}
|
|
|
|
#[test]
|
|
fn extractor_contract_rejects_unknown_or_misspelled_fields() {
|
|
let mut value = serde_json::to_value(request(DataGridExtractorId::Csv)).expect("serialize extractor request");
|
|
value["options"]["sql"]["skipComputedColumn"] = json!(false);
|
|
|
|
let error = serde_json::from_value::<DataGridExtractRequest>(value).expect_err("unknown option must fail");
|
|
|
|
assert!(error.to_string().contains("skipComputedColumn"));
|
|
}
|
|
|
|
#[test]
|
|
fn rejects_invalid_contract_and_column_mappings_fail_fast() {
|
|
let mut unsupported = request(DataGridExtractorId::Csv);
|
|
unsupported.version = 2;
|
|
assert_eq!(
|
|
extract_data_grid_selection(unsupported).expect_err("unsupported contract version").code,
|
|
DataGridExtractErrorCode::UnsupportedVersion
|
|
);
|
|
|
|
let mut invalid_column = request(DataGridExtractorId::Csv);
|
|
invalid_column.selected_column_indexes = vec![99];
|
|
assert_eq!(
|
|
extract_data_grid_selection(invalid_column).expect_err("invalid selected column").code,
|
|
DataGridExtractErrorCode::InvalidColumnIndex
|
|
);
|
|
|
|
let mut duplicate_column = request(DataGridExtractorId::Csv);
|
|
duplicate_column.selected_column_indexes = vec![0, 0];
|
|
assert_eq!(
|
|
extract_data_grid_selection(duplicate_column).expect_err("duplicate selected column").code,
|
|
DataGridExtractErrorCode::InvalidColumnIndex
|
|
);
|
|
|
|
let mut invalid_mapping = request(DataGridExtractorId::Csv);
|
|
invalid_mapping.columns[0].source_index = 99;
|
|
assert_eq!(
|
|
extract_data_grid_selection(invalid_mapping).expect_err("invalid source mapping").code,
|
|
DataGridExtractErrorCode::InvalidColumnMapping
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn sql_updates_require_table_primary_key_and_writable_columns() {
|
|
let missing_table = request(DataGridExtractorId::SqlUpdates);
|
|
assert_eq!(
|
|
extract_data_grid_selection(missing_table).expect_err("missing table metadata").code,
|
|
DataGridExtractErrorCode::MissingTableMetadata
|
|
);
|
|
|
|
let mut missing_primary_key = request(DataGridExtractorId::SqlUpdates);
|
|
missing_primary_key.table_meta = Some(DataGridTableMeta {
|
|
catalog: None,
|
|
database: None,
|
|
schema: None,
|
|
table_name: "users".to_string(),
|
|
primary_keys: Vec::new(),
|
|
columns: None,
|
|
});
|
|
assert_eq!(
|
|
extract_data_grid_selection(missing_primary_key).expect_err("missing primary key").code,
|
|
DataGridExtractErrorCode::MissingPrimaryKey
|
|
);
|
|
|
|
let mut primary_key_only = request(DataGridExtractorId::SqlUpdates);
|
|
primary_key_only.selected_column_indexes = vec![0];
|
|
primary_key_only.table_meta = Some(DataGridTableMeta {
|
|
catalog: None,
|
|
database: None,
|
|
schema: None,
|
|
table_name: "users".to_string(),
|
|
primary_keys: vec!["id".to_string()],
|
|
columns: None,
|
|
});
|
|
assert_eq!(
|
|
extract_data_grid_selection(primary_key_only).expect_err("primary-key-only update").code,
|
|
DataGridExtractErrorCode::NoWritableColumns
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn rejects_requests_that_exceed_the_column_budget() {
|
|
let mut request = request(DataGridExtractorId::Csv);
|
|
request.columns =
|
|
(0..=DATA_GRID_EXTRACTOR_MAX_COLUMNS).map(|index| column(&format!("column_{index}"), index)).collect();
|
|
|
|
let error = extract_data_grid_selection(request).expect_err("oversized column list must fail");
|
|
|
|
assert_eq!(error.code, DataGridExtractErrorCode::InputTooLarge);
|
|
}
|
|
|
|
#[test]
|
|
fn rejects_requests_that_exceed_the_selected_index_budget() {
|
|
// columns list is small, but selected_column_indexes is oversized —
|
|
// the budget must catch it before Vec::with_capacity allocates.
|
|
let mut request = request(DataGridExtractorId::Csv);
|
|
request.selected_column_indexes = (0..=DATA_GRID_EXTRACTOR_MAX_COLUMNS).collect();
|
|
|
|
let error = extract_data_grid_selection(request).expect_err("oversized index list must fail");
|
|
|
|
assert_eq!(error.code, DataGridExtractErrorCode::InputTooLarge);
|
|
}
|
|
|
|
#[test]
|
|
fn bounded_output_stops_before_allocating_past_the_limit() {
|
|
let mut output = BoundedOutput::new(4);
|
|
assert_eq!(output.write(b"1234").expect("bounded write"), 4);
|
|
assert!(output.write(b"5").is_err());
|
|
assert!(output.exceeded_limit());
|
|
assert_eq!(output.into_bytes(), b"1234");
|
|
}
|
|
|
|
#[test]
|
|
fn rejects_requests_that_exceed_the_row_budget_before_mapping_values() {
|
|
let mut request = request(DataGridExtractorId::Csv);
|
|
request.rows = vec![Vec::new(); DATA_GRID_EXTRACTOR_MAX_ROWS + 1];
|
|
|
|
let error = extract_data_grid_selection(request).expect_err("oversized request must fail");
|
|
|
|
assert_eq!(error.code, DataGridExtractErrorCode::InputTooLarge);
|
|
}
|
|
|
|
#[test]
|
|
fn rejects_estimated_oversized_sql_before_building_the_statement() {
|
|
let mut request = request(DataGridExtractorId::SqlInserts);
|
|
request.columns = vec![column("payload", 0)];
|
|
request.selected_column_indexes = vec![0];
|
|
request.rows = vec![vec![json!("x".repeat(DATA_GRID_EXTRACTOR_MAX_OUTPUT_BYTES / 6 + 1))]];
|
|
|
|
let error = extract_data_grid_selection(request).expect_err("oversized SQL must fail before allocation");
|
|
|
|
assert_eq!(error.code, DataGridExtractErrorCode::OutputTooLarge);
|
|
}
|