feat(grid): copy selected data as SELECT

Closes #5591
This commit is contained in:
t8y2 committed 2026-08-14 01:47:05 +00:00
1 parent c892c8d1b0
commit 278429ab07
18 files changed
+337 -11

No files matched your search

@@ -31,6 +31,7 @@ pub enum DataGridExtractorId {
SqlInList,
SqlInserts,
SqlUpdates,
SqlSelect,
WhereClause,
Markdown,
Html,
@@ -147,6 +148,8 @@ pub struct DataGridExtractRequest {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub database_type: Option<DatabaseType>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub identifier_quote: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub table_meta: Option<DataGridTableMeta>,
#[serde(default)]
pub columns: Vec<DataGridExtractColumn>,
@@ -198,6 +201,7 @@ pub enum DataGridExtractErrorCode {
UnsupportedVersion,
EmptySelection,
InvalidRawSelection,
InvalidSelectSelection,
InvalidColumnIndex,
InvalidColumnMapping,
MissingTableMetadata,
@@ -14,7 +14,7 @@ use delimited::{write_dsv, write_one_row};
use document::{write_html, write_markdown, write_pretty, write_xml};
use json::{write_json, write_json_lines};
use raw::write_raw;
use sql::{write_sql_in_list, write_sql_inserts, write_sql_updates, write_where_clause};
use sql::{write_sql_in_list, write_sql_inserts, write_sql_select, write_sql_updates, write_where_clause};
const DATA_GRID_EXTRACTOR_MAX_OUTPUT_BYTES: usize = 32 * 1024 * 1024;
const DATA_GRID_EXTRACTOR_MAX_INPUT_BYTES: usize = 64 * 1024 * 1024;
@@ -319,6 +319,10 @@ fn write_extraction(
}
DataGridExtractorId::SqlInserts => write_sql_inserts(context, output),
DataGridExtractorId::SqlUpdates => write_sql_updates(context, output),
DataGridExtractorId::SqlSelect => {
write_sql_select(context, output)?;
Ok(text_metadata("application/sql", "sql"))
}
DataGridExtractorId::WhereClause => {
write_where_clause(context, output)?;
Ok(text_metadata("application/sql", "sql"))
@@ -5,9 +5,9 @@ use super::{
};
use crate::data_grid_sql::{
build_column_predicate, build_data_grid_copy_insert_statement, build_data_grid_copy_update_statements,
format_grid_sql_literal, is_auto_generated_column, is_grid_insert_omitted_column, is_non_identity_generated_column,
supports_relational_copy_predicates, DataGridCopyInsertStatementOptions, DataGridCopyUpdateStatementOptions,
DataGridTableMeta,
data_grid_qualified_table_name, format_grid_sql_literal, is_auto_generated_column, is_grid_insert_omitted_column,
is_non_identity_generated_column, supports_relational_copy_predicates, DataGridCopyInsertStatementOptions,
DataGridCopyUpdateStatementOptions, DataGridTableMeta,
};
use serde_json::Value;
use std::collections::HashSet;
@@ -312,6 +312,102 @@ pub(super) fn write_where_clause(
Ok(())
}
pub(super) fn write_sql_select(
context: &ExtractContext<'_>,
output: &mut dyn Write,
) -> Result<(), DataGridExtractError> {
ensure_sql_builder_budget(context)?;
if !supports_relational_copy_predicates(context.request.database_type) {
return Err(DataGridExtractError::new(
DataGridExtractErrorCode::UnsupportedDatabase,
"SELECT extraction is not supported for this database type.",
));
}
let table_meta =
context.request.table_meta.as_ref().filter(|meta| !meta.table_name.trim().is_empty()).ok_or_else(|| {
DataGridExtractError::new(
DataGridExtractErrorCode::MissingTableMetadata,
"SELECT extraction requires one resolved table target.",
)
})?;
if context.request.rows.len() != 1
|| matches!(context.request.selection_kind, super::DataGridSelectionKind::Columns)
|| (context.request.selection_kind == super::DataGridSelectionKind::Cells
&& context.selected_columns.len() != 1)
{
return Err(DataGridExtractError::new(
DataGridExtractErrorCode::InvalidSelectSelection,
"SELECT extraction supports exactly one selected cell or row.",
));
}
let row = &context.request.rows[0];
let predicate_columns = if context.request.selection_kind == super::DataGridSelectionKind::Rows {
let identity = table_meta
.primary_keys
.iter()
.map(|primary_key| {
context
.request
.columns
.iter()
.find(|column| {
normalized_name_eq(column.source_name.as_deref().unwrap_or(&column.display_name), primary_key)
})
.filter(|column| row.get(column.source_index).is_some_and(|value| !value.is_null()))
})
.collect::<Option<Vec<_>>>();
identity.filter(|columns| !columns.is_empty()).unwrap_or_else(|| context.request.columns.iter().collect())
} else {
context.selected_columns.clone()
};
if predicate_columns.is_empty() {
return Err(DataGridExtractError::new(
DataGridExtractErrorCode::InvalidColumnMapping,
"SELECT extraction has no source columns for its predicate.",
));
}
let mut predicates = Vec::with_capacity(predicate_columns.len());
for column in predicate_columns {
let value = row.get(column.source_index).ok_or_else(|| {
DataGridExtractError::new(
DataGridExtractErrorCode::InvalidColumnMapping,
format!("Column '{}' maps to missing row index {}.", column.display_name, column.source_index),
)
})?;
let source_name = column.source_name.as_deref().filter(|name| !name.trim().is_empty()).ok_or_else(|| {
DataGridExtractError::new(
DataGridExtractErrorCode::InvalidColumnMapping,
format!("Column '{}' has no resolved source-column mapping.", column.display_name),
)
})?;
let column_info = table_meta
.columns
.as_deref()
.unwrap_or_default()
.iter()
.find(|info| normalized_name_eq(&info.name, source_name));
predicates.push(build_column_predicate(
context.request.database_type,
source_name,
value,
column_info,
true,
context.request.identifier_quote.as_deref(),
));
}
let table = data_grid_qualified_table_name(
context.request.database_type,
table_meta.catalog.as_deref(),
table_meta.schema.as_deref(),
table_meta.database.as_deref(),
&table_meta.table_name,
context.request.identifier_quote.as_deref(),
);
write_bytes(output, format!("SELECT * FROM {table} WHERE {};", predicates.join(" AND ")).as_bytes())
}
fn sql_metadata(omitted_columns: Vec<String>) -> WriteMetadata {
let warnings = if omitted_columns.is_empty() {
Vec::new()
@@ -12,6 +12,7 @@ fn request(extractor: DataGridExtractorId) -> 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],
@@ -358,6 +359,86 @@ fn builds_null_safe_where_clause_predicates() {
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_rejects_ambiguous_selection_and_missing_target() {
let error = extract_data_grid_selection(request(DataGridExtractorId::SqlSelect))
.expect_err("multiple 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,
});
let error = extract_data_grid_selection(request).expect_err("multiple cells 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
+1 -1
View File
@@ -2857,7 +2857,7 @@ fn data_grid_identifier(database_type: Option<DatabaseType>, name: &str, identif
crate::sql_dialect::quote_table_data_identifier(database_type, name, identifier_quote)
}
fn data_grid_qualified_table_name(
pub(crate) fn data_grid_qualified_table_name(
database_type: Option<DatabaseType>,
catalog: Option<&str>,
schema: Option<&str>,