1459 lines
62 KiB
Rust
1459 lines
62 KiB
Rust
use crate::models::connection::DatabaseType;
|
|
|
|
use super::capabilities::{
|
|
firebird_rows_clause, table_pagination_strategy, uses_oracle_row_id, uses_xugu_row_id, TablePaginationStrategy,
|
|
};
|
|
use super::identifiers::{
|
|
normalize_where_input, parse_sqlserver_linked_schema_ref, qualified_table_name, qualified_table_name_with_catalog,
|
|
quote_gaussdb_jdbc_identifier, quote_iris_identifier, quote_table_identifier,
|
|
};
|
|
use super::types::{
|
|
TableDataSelectSqlOptions, TableSelectSqlOptions, DBX_NEO4J_ELEMENT_ID_COLUMN, DBX_ROWID_COLUMN,
|
|
DBX_TDENGINE_TBNAME_COLUMN,
|
|
};
|
|
|
|
pub const DBX_LARGE_VALUE_BYTES_COLUMN_PREFIX: &str = "__DBX_LARGE_VALUE_BYTES_";
|
|
|
|
#[derive(Clone, Copy, PartialEq, Eq)]
|
|
enum LargeValuePreviewKind {
|
|
Text,
|
|
Binary,
|
|
TextCast,
|
|
Vector,
|
|
}
|
|
|
|
fn large_value_marker_alias_kind(kind: LargeValuePreviewKind, data_type: &str) -> &'static str {
|
|
match kind {
|
|
LargeValuePreviewKind::Binary => "B",
|
|
LargeValuePreviewKind::Vector => "V",
|
|
LargeValuePreviewKind::TextCast => match normalized_data_type_base(data_type).as_str() {
|
|
"json" => "J",
|
|
"jsonb" => "K",
|
|
"tsvector" => "S",
|
|
_ => "T",
|
|
},
|
|
LargeValuePreviewKind::Text => "T",
|
|
}
|
|
}
|
|
|
|
fn normalized_data_type_base(data_type: &str) -> String {
|
|
data_type.trim().split(['(', '[']).next().unwrap_or_default().trim().to_ascii_lowercase()
|
|
}
|
|
|
|
fn declared_data_type_length(data_type: &str) -> Option<usize> {
|
|
let parameters = data_type.split_once('(')?.1;
|
|
let digits = parameters.trim_start().chars().take_while(char::is_ascii_digit).collect::<String>();
|
|
(!digits.is_empty()).then(|| digits.parse::<usize>().ok()).flatten()
|
|
}
|
|
|
|
fn large_value_preview_kind(
|
|
database_type: Option<DatabaseType>,
|
|
data_type: &str,
|
|
preview_size: usize,
|
|
) -> Option<LargeValuePreviewKind> {
|
|
let normalized = data_type.trim().to_ascii_lowercase();
|
|
let base = normalized_data_type_base(data_type);
|
|
match database_type {
|
|
Some(DatabaseType::Mysql) => {
|
|
if matches!(base.as_str(), "blob" | "mediumblob" | "longblob")
|
|
|| (base == "varbinary"
|
|
&& declared_data_type_length(data_type).is_some_and(|length| length > preview_size))
|
|
{
|
|
Some(LargeValuePreviewKind::Binary)
|
|
} else if base == "json" {
|
|
Some(LargeValuePreviewKind::TextCast)
|
|
} else if matches!(base.as_str(), "text" | "mediumtext" | "longtext")
|
|
|| (base == "varchar"
|
|
&& declared_data_type_length(data_type).is_some_and(|length| length > preview_size))
|
|
{
|
|
Some(LargeValuePreviewKind::Text)
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
Some(DatabaseType::Postgres) => {
|
|
if normalized.contains('[') {
|
|
None
|
|
} else if base == "bytea" {
|
|
Some(LargeValuePreviewKind::Binary)
|
|
} else if matches!(base.as_str(), "char" | "character" | "varchar" | "text" | "citext" | "name")
|
|
|| normalized.starts_with("character varying")
|
|
{
|
|
Some(LargeValuePreviewKind::Text)
|
|
} else if base == "vector" {
|
|
Some(LargeValuePreviewKind::Vector)
|
|
} else if matches!(base.as_str(), "json" | "jsonb" | "tsvector" | "xml") {
|
|
// `xml` must be cast to text: there is no `left(xml, int)`
|
|
// overload and no implicit xml -> text cast, so the preview
|
|
// would otherwise fail with
|
|
// `function left(xml, integer) does not exist`.
|
|
Some(LargeValuePreviewKind::TextCast)
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
fn build_large_value_preview_columns(options: &TableDataSelectSqlOptions) -> Option<String> {
|
|
let database_type = options.database_type;
|
|
let preview_size = options.large_value_preview_size?.max(1);
|
|
if options.columns.is_empty()
|
|
|| options.columns.len() != options.column_types.len()
|
|
|| options.primary_keys.is_empty()
|
|
|| options
|
|
.columns
|
|
.iter()
|
|
.any(|column| column.to_ascii_uppercase().starts_with(DBX_LARGE_VALUE_BYTES_COLUMN_PREFIX))
|
|
{
|
|
return None;
|
|
}
|
|
|
|
let protected: std::collections::HashSet<String> =
|
|
options.primary_keys.iter().map(|column| column.to_ascii_lowercase()).collect();
|
|
let mut projections = Vec::with_capacity(options.columns.len() * 2);
|
|
let mut marker_count = 0;
|
|
for (column_index, (column, data_type)) in options.columns.iter().zip(&options.column_types).enumerate() {
|
|
let quoted = if uses_connection_identifier_quote(database_type, options.identifier_quote.as_deref()) {
|
|
quote_table_data_identifier(database_type, column, options.identifier_quote.as_deref())
|
|
} else {
|
|
quote_table_identifier(database_type, column)
|
|
};
|
|
let kind = (!protected.contains(&column.to_ascii_lowercase()))
|
|
.then(|| large_value_preview_kind(database_type, data_type, preview_size))
|
|
.flatten();
|
|
let Some(kind) = kind else {
|
|
projections.push(quoted);
|
|
continue;
|
|
};
|
|
|
|
let alias_kind = large_value_marker_alias_kind(kind, data_type);
|
|
let marker_alias = quote_table_identifier(
|
|
database_type,
|
|
&format!("{DBX_LARGE_VALUE_BYTES_COLUMN_PREFIX}{alias_kind}_{column_index}"),
|
|
);
|
|
let prefix_size = preview_size.saturating_add(1);
|
|
let (preview, marker_kind) = match database_type {
|
|
Some(DatabaseType::Mysql) if kind == LargeValuePreviewKind::Binary => {
|
|
(format!("LEFT({quoted}, {prefix_size}) AS {quoted}"), "B")
|
|
}
|
|
Some(DatabaseType::Mysql) => (format!("LEFT({quoted}, {prefix_size}) AS {quoted}"), "T"),
|
|
Some(DatabaseType::Postgres) if kind == LargeValuePreviewKind::Binary => {
|
|
(format!("substring({quoted} from 1 for {prefix_size}) AS {quoted}"), "B")
|
|
}
|
|
Some(DatabaseType::Postgres) if kind == LargeValuePreviewKind::TextCast => {
|
|
(format!("left({quoted}::text, {prefix_size}) AS {quoted}"), "T")
|
|
}
|
|
Some(DatabaseType::Postgres) if kind == LargeValuePreviewKind::Vector => {
|
|
(format!("left({quoted}::text, {prefix_size}) AS {quoted}"), "V")
|
|
}
|
|
Some(DatabaseType::Postgres) => (format!("left({quoted}, {prefix_size}) AS {quoted}"), "T"),
|
|
_ => return None,
|
|
};
|
|
let marker = if database_type == Some(DatabaseType::Mysql) {
|
|
format!("CONCAT('{marker_kind}:{preview_size}:', LENGTH({quoted})) AS {marker_alias}")
|
|
} else {
|
|
format!("'{marker_kind}:{preview_size}' AS {marker_alias}")
|
|
};
|
|
projections.push(preview);
|
|
projections.push(marker);
|
|
marker_count += 1;
|
|
}
|
|
(marker_count > 0).then(|| projections.join(", "))
|
|
}
|
|
|
|
pub fn build_count_table_sql(database_type: Option<DatabaseType>, schema: Option<&str>, table_name: &str) -> String {
|
|
if database_type == Some(DatabaseType::VictoriaMetrics) {
|
|
return format!("count({})", victoriametrics_metric_selector(table_name));
|
|
}
|
|
format!("SELECT COUNT(*) AS row_count FROM {}", qualified_table_name(database_type, schema, table_name))
|
|
}
|
|
|
|
pub fn table_data_schema<'a>(
|
|
database_type: Option<DatabaseType>,
|
|
driver_profile: Option<&str>,
|
|
schema: Option<&'a str>,
|
|
) -> Option<&'a str> {
|
|
if database_type == Some(DatabaseType::Informix)
|
|
&& driver_profile.is_some_and(|profile| profile.eq_ignore_ascii_case("gbase8s"))
|
|
{
|
|
None
|
|
} else {
|
|
schema
|
|
}
|
|
}
|
|
|
|
/// Builds the SQL used by the data-table grid. Database qualification is opt-in
|
|
/// so existing callers retain their current SQL shape.
|
|
pub fn build_table_data_select_sql(options: TableDataSelectSqlOptions) -> String {
|
|
build_table_data_select_sql_with_database(options, false)
|
|
}
|
|
|
|
pub fn build_table_data_select_sql_with_database(
|
|
options: TableDataSelectSqlOptions,
|
|
include_database_name: bool,
|
|
) -> String {
|
|
let database_type = options.database_type;
|
|
let schema = table_data_schema(database_type, options.driver_profile.as_deref(), options.schema.as_deref());
|
|
let limit = options.limit.unwrap_or(100);
|
|
if database_type == Some(DatabaseType::Neo4j) {
|
|
return build_neo4j_table_select_sql(&options, limit);
|
|
}
|
|
if database_type == Some(DatabaseType::Nebula) {
|
|
return build_nebula_table_select_sql(&options, limit);
|
|
}
|
|
if database_type == Some(DatabaseType::Salesforce) {
|
|
return build_salesforce_table_select_sql(&options, limit);
|
|
}
|
|
if database_type == Some(DatabaseType::VictoriaMetrics) {
|
|
return format!("{}[1h]", victoriametrics_metric_selector(&options.table_name));
|
|
}
|
|
|
|
// TDengine's JDBC connection context setters do not affect WebSocket statements,
|
|
// so table reads must carry the selected database in the SQL itself.
|
|
let jdbc_tdengine_database = (database_type == Some(DatabaseType::Jdbc)
|
|
&& options.driver_profile.as_deref().is_some_and(|profile| profile.trim().eq_ignore_ascii_case("tdengine")))
|
|
.then(|| options.database.as_deref().map(str::trim).filter(|database| !database.is_empty()).or(schema))
|
|
.flatten();
|
|
let table = if let Some(database) = jdbc_tdengine_database {
|
|
qualified_table_name(Some(DatabaseType::Tdengine), Some(database), &options.table_name)
|
|
// Doris / StarRocks multi-catalog: prefix the catalog for external-catalog tables.
|
|
} else if database_type == Some(DatabaseType::Iris)
|
|
|| uses_connection_identifier_quote(database_type, options.identifier_quote.as_deref())
|
|
{
|
|
table_data_qualified_table_name(database_type, schema, &options.table_name, options.identifier_quote.as_deref())
|
|
} else if include_database_name {
|
|
database_qualified_table_name(
|
|
database_type,
|
|
options.catalog.as_deref(),
|
|
schema,
|
|
options.database.as_deref(),
|
|
&options.table_name,
|
|
)
|
|
.unwrap_or_else(|| {
|
|
qualified_table_name_with_catalog(
|
|
database_type,
|
|
options.catalog.as_deref(),
|
|
schema,
|
|
options.database.as_deref(),
|
|
&options.table_name,
|
|
)
|
|
})
|
|
} else {
|
|
qualified_table_name_with_catalog(
|
|
database_type,
|
|
options.catalog.as_deref(),
|
|
schema,
|
|
options.database.as_deref(),
|
|
&options.table_name,
|
|
)
|
|
};
|
|
let predicate = normalize_where_input(options.where_input.as_deref());
|
|
// Time-series engines like InfluxDB scan every shard when no time
|
|
// predicate is given, which turns the sidebar quick-open ("show me
|
|
// the latest rows") into a full-shard scan on any non-trivial
|
|
// dataset. Data-tab callers opt in to a rolling 5-minute window when
|
|
// the user has not provided their own WHERE; sampling and export
|
|
// callers keep the historical unfiltered behavior, and users can
|
|
// broaden the window by editing the SQL.
|
|
let effective_predicate = if predicate.is_empty() && options.inject_default_time_series_where {
|
|
default_time_series_predicate(database_type).unwrap_or_default()
|
|
} else {
|
|
predicate
|
|
};
|
|
let where_clause =
|
|
if effective_predicate.is_empty() { String::new() } else { format!(" WHERE ({effective_predicate})") };
|
|
let default_order_by = if matches!(database_type, Some(DatabaseType::InfluxDb) | Some(DatabaseType::InfluxDb3)) {
|
|
// InfluxQL only allows sorting of the timestamp column; SQL-mode
|
|
// InfluxDB 3 tables also key naturally on `time`.
|
|
Some("time DESC".to_string())
|
|
} else if database_type == Some(DatabaseType::Impala) {
|
|
// Impala requires ORDER BY when OFFSET is present. Keeping the same
|
|
// fallback on the first page also prevents page boundaries from using
|
|
// different row orders when the table has no explicit key.
|
|
Some("1".to_string())
|
|
} else {
|
|
None
|
|
};
|
|
let order_by = options.order_by.as_deref().filter(|order| !order.trim().is_empty()).or(default_order_by.as_deref());
|
|
let order = order_by.map(|order_by| format!(" ORDER BY {order_by}")).unwrap_or_default();
|
|
// Oracle views with DISTINCT/GROUP BY raise ORA-01446 when ROWID is
|
|
// selected. Missing object metadata must therefore fail closed instead of
|
|
// being treated as a base table.
|
|
let include_oracle_row_id = options.include_row_id
|
|
&& uses_oracle_row_id(database_type)
|
|
&& is_oracle_base_table_type(options.table_type.as_deref());
|
|
let include_xugu_row_id =
|
|
options.include_row_id && uses_xugu_row_id(database_type) && !is_view_table_type(options.table_type.as_deref());
|
|
let offset = options.offset.unwrap_or(0);
|
|
let select_columns = if include_oracle_row_id {
|
|
format!("ROWIDTOCHAR(t.ROWID) AS \"{DBX_ROWID_COLUMN}\", t.*")
|
|
} else if let Some(preview_columns) = build_large_value_preview_columns(&options) {
|
|
preview_columns
|
|
} else if include_xugu_row_id {
|
|
if options.columns.is_empty() {
|
|
format!("ROWID AS \"{DBX_ROWID_COLUMN}\", *")
|
|
} else {
|
|
format!(
|
|
"ROWID AS \"{DBX_ROWID_COLUMN}\", {}",
|
|
quoted_table_columns_or_star(database_type, &options.columns)
|
|
)
|
|
}
|
|
} else {
|
|
build_select_columns(
|
|
database_type,
|
|
&options.columns,
|
|
tdengine_should_include_tbname(database_type, options.table_type.as_deref()),
|
|
options.identifier_quote.as_deref(),
|
|
)
|
|
};
|
|
let rownum_select_columns = quoted_table_columns_or_star(database_type, &options.columns);
|
|
let page_select_columns = if include_oracle_row_id {
|
|
if options.columns.is_empty() {
|
|
"*".to_string()
|
|
} else {
|
|
// Callers that address rows by the synthetic key may list it among
|
|
// the requested columns; the leading projection already supplies
|
|
// it from the inline view, so drop the duplicate.
|
|
let rest = options
|
|
.columns
|
|
.iter()
|
|
.filter(|column| !column.eq_ignore_ascii_case(DBX_ROWID_COLUMN))
|
|
.map(|column| quote_table_identifier(database_type, column))
|
|
.collect::<Vec<_>>()
|
|
.join(", ");
|
|
if rest.is_empty() {
|
|
format!("\"{DBX_ROWID_COLUMN}\"")
|
|
} else {
|
|
format!("\"{DBX_ROWID_COLUMN}\", {rest}")
|
|
}
|
|
}
|
|
} else {
|
|
rownum_select_columns.clone()
|
|
};
|
|
let table_alias = if include_oracle_row_id { format!("{table} t") } else { table };
|
|
|
|
match table_pagination_strategy(database_type) {
|
|
TablePaginationStrategy::IrisTop => {
|
|
if options.use_driver_row_offset {
|
|
format!("SELECT {select_columns} FROM {table_alias}{where_clause}{order}")
|
|
} else {
|
|
build_iris_table_select_sql(&select_columns, &table_alias, &where_clause, &order, limit, offset as u64)
|
|
}
|
|
}
|
|
TablePaginationStrategy::InformixFirst => {
|
|
let row_limit = informix_row_limit_clause(limit, options.offset.unwrap_or(0));
|
|
format!("SELECT {row_limit} {select_columns} FROM {table_alias}{where_clause}{order}")
|
|
}
|
|
TablePaginationStrategy::FirebirdRows => {
|
|
let rows = firebird_rows_clause(limit, options.offset.unwrap_or(0));
|
|
format!("SELECT {select_columns} FROM {table_alias}{where_clause}{order} {rows}")
|
|
}
|
|
TablePaginationStrategy::Db2FetchFirst if options.offset.is_some_and(|offset| offset > 0) => {
|
|
build_db2_table_select_page_sql(
|
|
&table_alias,
|
|
&where_clause,
|
|
order_by,
|
|
&options.columns,
|
|
limit,
|
|
options.offset.unwrap_or(0),
|
|
)
|
|
}
|
|
TablePaginationStrategy::Db2FetchFirst | TablePaginationStrategy::FetchFirst => {
|
|
let offset = options
|
|
.offset
|
|
.filter(|offset| *offset > 0)
|
|
.map(|offset| format!(" OFFSET {offset} ROWS"))
|
|
.unwrap_or_default();
|
|
format!(
|
|
"SELECT {select_columns} FROM {table_alias}{where_clause}{order}{offset} FETCH FIRST {limit} ROWS ONLY"
|
|
)
|
|
}
|
|
TablePaginationStrategy::Rownum => {
|
|
let rownum_inner_select_columns =
|
|
if include_oracle_row_id { &select_columns } else { &rownum_select_columns };
|
|
build_rownum_table_select_sql(
|
|
&table_alias,
|
|
&where_clause,
|
|
&order,
|
|
rownum_inner_select_columns,
|
|
&page_select_columns,
|
|
limit,
|
|
offset,
|
|
)
|
|
}
|
|
TablePaginationStrategy::Unbounded => {
|
|
format!("SELECT {select_columns} FROM {table_alias}{where_clause}{order}")
|
|
}
|
|
TablePaginationStrategy::SqlServerTop => build_sqlserver_table_select_sql(
|
|
&table_alias,
|
|
&where_clause,
|
|
order_by.unwrap_or("(SELECT NULL)"),
|
|
&options.columns,
|
|
limit,
|
|
options.offset.unwrap_or(0),
|
|
options
|
|
.driver_profile
|
|
.as_deref()
|
|
.is_some_and(|profile| profile.trim().eq_ignore_ascii_case("sqlserver-legacy")),
|
|
),
|
|
TablePaginationStrategy::QuestDbLimit => build_questdb_table_select_sql(
|
|
&table_alias,
|
|
&where_clause,
|
|
&order,
|
|
&options.columns,
|
|
limit,
|
|
options.offset.unwrap_or(0),
|
|
),
|
|
TablePaginationStrategy::AgentMaxRows => {
|
|
format!("SELECT {select_columns} FROM {table_alias}{where_clause}{order};")
|
|
}
|
|
TablePaginationStrategy::LimitOffset => {
|
|
let offset = options
|
|
.offset
|
|
.filter(|offset| *offset > 0)
|
|
.map(|offset| format!(" OFFSET {offset}"))
|
|
.unwrap_or_default();
|
|
format!("SELECT {select_columns} FROM {table_alias}{where_clause}{order} LIMIT {limit}{offset};")
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Default WHERE predicate for time-series engines whose data model
|
|
/// makes an unbounded `SELECT *` an accidental full-shard scan. When a
|
|
/// data-tab caller opts in and the user has not supplied their own
|
|
/// WHERE, we inject a rolling five-minute window on the mandatory
|
|
/// `time` column so that sidebar quick-open queries stay cheap on
|
|
/// production-sized tables. Users can broaden or drop the filter by
|
|
/// editing the generated SQL.
|
|
///
|
|
/// Syntax is per-engine and cannot be shared:
|
|
///
|
|
/// * **InfluxDB 1.x / 2.x** — sidebar SELECTs go to the `/query`
|
|
/// endpoint and are parsed as InfluxQL. InfluxQL accepts Go-style
|
|
/// duration literals directly (`5m`, `1h`, `30s`).
|
|
/// * **InfluxDB 3.x** — queries go through DataFusion SQL and require
|
|
/// ANSI interval literals (`INTERVAL '5 minutes'`).
|
|
///
|
|
/// Returns `None` for engines where no default is appropriate — the
|
|
/// caller then falls through to the historical unfiltered behavior.
|
|
fn default_time_series_predicate(database_type: Option<DatabaseType>) -> Option<String> {
|
|
match database_type? {
|
|
DatabaseType::InfluxDb => Some("time > now() - 5m".to_string()),
|
|
DatabaseType::InfluxDb3 => Some("time > now() - INTERVAL '5 minutes'".to_string()),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
/// Returns the fully qualified reference for engines whose active database is
|
|
/// normally omitted from generated table SQL:
|
|
///
|
|
/// - `database.table` for MySQL-compatible engines and ClickHouse;
|
|
/// - `database.schema.table` for SQL Server, whose tables are addressable
|
|
/// across databases on the same connection;
|
|
/// - Doris and StarRocks keep their external catalog prefix
|
|
/// (`catalog.database.table`).
|
|
///
|
|
/// Shared by every "generated table SQL" surface that honors the
|
|
/// `生成 SQL 时包含数据库名` setting, so the grid label, the copy-as-INSERT/UPDATE/
|
|
/// SELECT statements and the data-grid save statements stay in sync.
|
|
///
|
|
/// `schema` wins over `database` for the MySQL family: after a cross-database
|
|
/// editable result (`SELECT * FROM db_9.users`) the table's own namespace lives
|
|
/// in `schema` while `database` still holds the connection's default database.
|
|
pub fn database_qualified_table_name(
|
|
database_type: Option<DatabaseType>,
|
|
catalog: Option<&str>,
|
|
schema: Option<&str>,
|
|
database: Option<&str>,
|
|
table_name: &str,
|
|
) -> Option<String> {
|
|
let database = database.map(str::trim).filter(|database| !database.is_empty())?;
|
|
match database_type {
|
|
Some(DatabaseType::ClickHouse) => Some(format!(
|
|
"{}.{}",
|
|
quote_table_identifier(database_type, database),
|
|
quote_table_identifier(database_type, table_name)
|
|
)),
|
|
Some(DatabaseType::Mysql | DatabaseType::Goldendb | DatabaseType::Doris | DatabaseType::StarRocks) => {
|
|
let namespace = schema.map(str::trim).filter(|schema| !schema.is_empty()).unwrap_or(database);
|
|
Some(qualified_table_name_with_catalog(
|
|
database_type,
|
|
catalog,
|
|
Some(namespace),
|
|
Some(namespace),
|
|
table_name,
|
|
))
|
|
}
|
|
Some(DatabaseType::SqlServer) => {
|
|
// A linked-server schema already carries `server|catalog|schema`, so
|
|
// prefixing it with the local database would produce a bogus name.
|
|
let schema = schema.map(str::trim).filter(|schema| !schema.is_empty())?;
|
|
if parse_sqlserver_linked_schema_ref(schema).is_some() {
|
|
return None;
|
|
}
|
|
Some(format!(
|
|
"{}.{}.{}",
|
|
quote_table_identifier(database_type, database),
|
|
quote_table_identifier(database_type, schema),
|
|
quote_table_identifier(database_type, table_name)
|
|
))
|
|
}
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
pub fn table_data_qualified_table_name(
|
|
database_type: Option<DatabaseType>,
|
|
schema: Option<&str>,
|
|
table_name: &str,
|
|
identifier_quote: Option<&str>,
|
|
) -> String {
|
|
if database_type == Some(DatabaseType::Iris) {
|
|
let table = quote_iris_identifier(table_name, identifier_quote);
|
|
return schema
|
|
.map(str::trim)
|
|
.filter(|schema| !schema.is_empty())
|
|
.map(|schema| format!("{}.{table}", quote_iris_identifier(schema, identifier_quote)))
|
|
.unwrap_or(table);
|
|
}
|
|
if !uses_connection_identifier_quote(database_type, identifier_quote) {
|
|
return qualified_table_name(database_type, schema, table_name);
|
|
}
|
|
let table = quote_table_data_identifier(database_type, table_name, identifier_quote);
|
|
schema
|
|
.map(str::trim)
|
|
.filter(|schema| !schema.is_empty())
|
|
.map(|schema| format!("{}.{}", quote_table_data_identifier(database_type, schema, identifier_quote), table))
|
|
.unwrap_or(table)
|
|
}
|
|
|
|
pub fn quote_table_data_identifier(
|
|
database_type: Option<DatabaseType>,
|
|
name: &str,
|
|
identifier_quote: Option<&str>,
|
|
) -> String {
|
|
if !uses_connection_identifier_quote(database_type, identifier_quote) {
|
|
return quote_table_identifier(database_type, name);
|
|
}
|
|
let Some(quote) = identifier_quote else {
|
|
return quote_table_identifier(database_type, name);
|
|
};
|
|
if matches!(database_type, Some(DatabaseType::Gaussdb | DatabaseType::OpenGauss | DatabaseType::Postgres)) {
|
|
return quote_gaussdb_jdbc_identifier(name, quote);
|
|
}
|
|
if quote.is_empty() {
|
|
return name.to_string();
|
|
}
|
|
format!("{quote}{}{quote}", name.replace(quote, &format!("{quote}{quote}")))
|
|
}
|
|
|
|
pub fn uses_connection_identifier_quote(database_type: Option<DatabaseType>, identifier_quote: Option<&str>) -> bool {
|
|
database_type == Some(DatabaseType::Kingbase)
|
|
// JDBC table-data requests carry the schema returned by DatabaseMetaData.
|
|
// Keep the JDBC identifier unquoted when no driver quote was reported, but
|
|
// still qualify the table with that schema.
|
|
|| database_type == Some(DatabaseType::Jdbc)
|
|
// Spanner is dual-dialect: GoogleSQL uses backticks, the PostgreSQL dialect uses
|
|
// double quotes, and only the connected agent knows which. Unconditional like
|
|
// Kingbase — when no quote was reported the callers fall back to
|
|
// `quote_table_identifier`, whose static mapping is GoogleSQL-correct.
|
|
|| database_type == Some(DatabaseType::Spanner)
|
|
// Kyuubi normally uses Hive-family backticks, but a Trino-backed
|
|
// session reports the ANSI double quote through connection info.
|
|
|| (database_type == Some(DatabaseType::Kyuubi) && identifier_quote.is_some())
|
|
|| (database_type == Some(DatabaseType::Informix) && identifier_quote.is_some())
|
|
|| (matches!(database_type, Some(DatabaseType::Gaussdb | DatabaseType::OpenGauss | DatabaseType::Postgres))
|
|
&& identifier_quote.is_some())
|
|
}
|
|
|
|
fn is_view_table_type(table_type: Option<&str>) -> bool {
|
|
table_type.is_some_and(|value| value.to_ascii_uppercase().contains("VIEW"))
|
|
}
|
|
|
|
fn is_oracle_base_table_type(table_type: Option<&str>) -> bool {
|
|
table_type.is_some_and(|value| value.trim().eq_ignore_ascii_case("TABLE"))
|
|
}
|
|
|
|
pub fn build_table_select_sql(options: TableSelectSqlOptions<'_>) -> String {
|
|
let database_type = options.database_type;
|
|
if database_type == Some(DatabaseType::VictoriaMetrics) {
|
|
return format!("{}[1h]", victoriametrics_metric_selector(options.table_name));
|
|
}
|
|
let table = if database_type == Some(DatabaseType::Iris) {
|
|
let table = quote_iris_identifier(options.table_name, None);
|
|
options
|
|
.schema
|
|
.map(str::trim)
|
|
.filter(|schema| !schema.is_empty())
|
|
.map(|schema| format!("{}.{table}", quote_iris_identifier(schema, None)))
|
|
.unwrap_or(table)
|
|
} else {
|
|
qualified_table_name(database_type, options.schema, options.table_name)
|
|
};
|
|
let select_columns = quoted_table_columns_or_star(database_type, options.columns);
|
|
let order_by = if options.order_columns.is_empty() {
|
|
String::new()
|
|
} else {
|
|
format!(
|
|
" ORDER BY {}",
|
|
options
|
|
.order_columns
|
|
.iter()
|
|
.map(|column| {
|
|
let quoted = if database_type == Some(DatabaseType::Iris) {
|
|
// Caché/IRIS may run with delimited identifiers disabled,
|
|
// where a quoted ORDER BY name becomes a string literal and
|
|
// silently degrades to a constant sort.
|
|
quote_iris_identifier(column, None)
|
|
} else {
|
|
quote_table_identifier(database_type, column)
|
|
};
|
|
format!("{quoted} ASC")
|
|
})
|
|
.collect::<Vec<_>>()
|
|
.join(", ")
|
|
)
|
|
};
|
|
let limit = options.limit;
|
|
|
|
match table_pagination_strategy(database_type) {
|
|
TablePaginationStrategy::IrisTop => format!("SELECT TOP {limit} {select_columns} FROM {table}{order_by}"),
|
|
TablePaginationStrategy::InformixFirst => {
|
|
format!("SELECT FIRST {limit} {select_columns} FROM {table}{order_by}")
|
|
}
|
|
TablePaginationStrategy::FirebirdRows => {
|
|
let rows = firebird_rows_clause(limit, 0);
|
|
format!("SELECT {select_columns} FROM {table}{order_by} {rows}")
|
|
}
|
|
TablePaginationStrategy::Rownum => {
|
|
build_rownum_table_select_sql(&table, "", &order_by, &select_columns, &select_columns, limit, 0)
|
|
}
|
|
TablePaginationStrategy::Db2FetchFirst | TablePaginationStrategy::FetchFirst => {
|
|
format!("SELECT {select_columns} FROM {table}{order_by} FETCH FIRST {limit} ROWS ONLY")
|
|
}
|
|
TablePaginationStrategy::SqlServerTop => {
|
|
format!("SELECT TOP ({limit}) {select_columns} FROM {table}{order_by}")
|
|
}
|
|
TablePaginationStrategy::AgentMaxRows => format!("SELECT {select_columns} FROM {table}{order_by};"),
|
|
TablePaginationStrategy::Unbounded => format!("SELECT {select_columns} FROM {table}{order_by}"),
|
|
TablePaginationStrategy::QuestDbLimit | TablePaginationStrategy::LimitOffset => {
|
|
format!("SELECT {select_columns} FROM {table}{order_by} LIMIT {limit};")
|
|
}
|
|
}
|
|
}
|
|
|
|
fn victoriametrics_metric_selector(metric_name: &str) -> String {
|
|
let escaped = metric_name.replace('\\', "\\\\").replace('"', "\\\"").replace('\n', "\\n");
|
|
format!(r#"{{__name__="{escaped}"}}"#)
|
|
}
|
|
|
|
fn informix_row_limit_clause(limit: usize, offset: usize) -> String {
|
|
if offset > 0 {
|
|
format!("SKIP {offset} FIRST {limit}")
|
|
} else {
|
|
format!("FIRST {limit}")
|
|
}
|
|
}
|
|
|
|
fn quoted_table_columns_or_star(database_type: Option<DatabaseType>, columns: &[String]) -> String {
|
|
if columns.is_empty() {
|
|
return "*".to_string();
|
|
}
|
|
columns
|
|
.iter()
|
|
.map(|column| {
|
|
if database_type == Some(DatabaseType::Iris) {
|
|
// With delimited identifiers disabled, the Caché/IRIS JDBC
|
|
// preparser turns a quoted column name into a `:%qpar` host
|
|
// variable, so ordinary names must stay unquoted.
|
|
quote_iris_identifier(column, None)
|
|
} else {
|
|
quote_table_identifier(database_type, column)
|
|
}
|
|
})
|
|
.collect::<Vec<_>>()
|
|
.join(", ")
|
|
}
|
|
|
|
/// Builds one page of a Caché/IRIS table read.
|
|
///
|
|
/// Caché and older IRIS SQL have `TOP` but no `OFFSET` clause, so later pages
|
|
/// bound a derived table with `TOP(offset + limit)` and drop the leading rows with `%VID`, the row
|
|
/// number InterSystems assigns to the rows a query produces. Running the same
|
|
/// `TOP limit` statement for every page was the reason the grid kept showing
|
|
/// the first page (#8929).
|
|
pub fn build_iris_table_select_sql(
|
|
select_columns: &str,
|
|
table_alias: &str,
|
|
where_clause: &str,
|
|
order: &str,
|
|
limit: usize,
|
|
offset: u64,
|
|
) -> String {
|
|
if offset == 0 {
|
|
return format!("SELECT TOP {limit} {select_columns} FROM {table_alias}{where_clause}{order}");
|
|
}
|
|
let window = offset.saturating_add(limit as u64);
|
|
format!(
|
|
"SELECT * FROM (SELECT TOP {window} {select_columns} FROM {table_alias}{where_clause}{order}) WHERE %VID > {offset}"
|
|
)
|
|
}
|
|
|
|
fn build_rownum_table_select_sql(
|
|
table: &str,
|
|
where_clause: &str,
|
|
order: &str,
|
|
inner_select_columns: &str,
|
|
outer_select_columns: &str,
|
|
limit: usize,
|
|
offset: usize,
|
|
) -> String {
|
|
let inner_select = format!("SELECT {inner_select_columns} FROM {table}{where_clause}{order}");
|
|
if offset == 0 {
|
|
return format!("SELECT {outer_select_columns} FROM ({inner_select}) WHERE ROWNUM <= {limit}");
|
|
}
|
|
|
|
let row_number_alias = quote_table_identifier(Some(DatabaseType::Oracle), "__dbx_row_num");
|
|
let end = offset + limit;
|
|
format!(
|
|
"SELECT {outer_select_columns} FROM (SELECT dbx_inner.*, ROWNUM AS {row_number_alias} FROM ({inner_select}) dbx_inner WHERE ROWNUM <= {end}) WHERE {row_number_alias} > {offset}"
|
|
)
|
|
}
|
|
|
|
pub(super) fn is_tdengine_tbname(database_type: Option<DatabaseType>, name: &str) -> bool {
|
|
database_type == Some(DatabaseType::Tdengine) && name.eq_ignore_ascii_case(DBX_TDENGINE_TBNAME_COLUMN)
|
|
}
|
|
|
|
fn tdengine_should_include_tbname(database_type: Option<DatabaseType>, table_type: Option<&str>) -> bool {
|
|
if database_type != Some(DatabaseType::Tdengine) {
|
|
return false;
|
|
}
|
|
matches!(
|
|
table_type.map(|value| value.trim().to_ascii_uppercase()),
|
|
Some(value) if value == "STABLE" || value == "SUPER TABLE" || value == "SUPERTABLE"
|
|
)
|
|
}
|
|
|
|
pub(super) fn build_select_columns(
|
|
database_type: Option<DatabaseType>,
|
|
columns: &[String],
|
|
include_tdengine_tbname: bool,
|
|
identifier_quote: Option<&str>,
|
|
) -> String {
|
|
if columns.is_empty() {
|
|
if database_type == Some(DatabaseType::Tdengine) && include_tdengine_tbname {
|
|
return format!("{DBX_TDENGINE_TBNAME_COLUMN}, *");
|
|
}
|
|
return "*".to_string();
|
|
}
|
|
if database_type == Some(DatabaseType::Tdengine) {
|
|
let mut tdengine_columns = Vec::new();
|
|
if include_tdengine_tbname
|
|
&& !columns.iter().any(|column| column.eq_ignore_ascii_case(DBX_TDENGINE_TBNAME_COLUMN))
|
|
{
|
|
tdengine_columns.push(DBX_TDENGINE_TBNAME_COLUMN.to_string());
|
|
}
|
|
tdengine_columns.extend(
|
|
columns
|
|
.iter()
|
|
.filter(|column| include_tdengine_tbname || !column.eq_ignore_ascii_case(DBX_TDENGINE_TBNAME_COLUMN))
|
|
.cloned(),
|
|
);
|
|
if tdengine_columns.is_empty() {
|
|
return "*".to_string();
|
|
}
|
|
return tdengine_columns
|
|
.iter()
|
|
.map(|column| {
|
|
if is_tdengine_tbname(database_type, column) {
|
|
DBX_TDENGINE_TBNAME_COLUMN.to_string()
|
|
} else {
|
|
let ident = quote_table_identifier(database_type, column);
|
|
format!("{ident} AS {ident}")
|
|
}
|
|
})
|
|
.collect::<Vec<_>>()
|
|
.join(", ");
|
|
}
|
|
// Everything outside the Hive-family identifier projection reads
|
|
// `SELECT *`. That includes InfluxDB (v1 / v2 / 3.x), whose tables
|
|
// can carry dozens of tags and fields — a full column list turns the
|
|
// generated SQL into a wall of names, while InfluxQL supports `*`
|
|
// natively and users can narrow the projection by editing the SQL.
|
|
if !matches!(
|
|
database_type,
|
|
Some(
|
|
DatabaseType::Hive
|
|
| DatabaseType::Kyuubi
|
|
| DatabaseType::Impala
|
|
| DatabaseType::Argo
|
|
| DatabaseType::Transwarp
|
|
)
|
|
) {
|
|
return "*".to_string();
|
|
}
|
|
columns
|
|
.iter()
|
|
.map(|column| {
|
|
let ident = if database_type == Some(DatabaseType::Kyuubi) {
|
|
quote_table_data_identifier(database_type, column, identifier_quote)
|
|
} else {
|
|
quote_table_identifier(database_type, column)
|
|
};
|
|
if database_type == Some(DatabaseType::Hive) {
|
|
format!("{ident} AS {ident}")
|
|
} else {
|
|
ident
|
|
}
|
|
})
|
|
.collect::<Vec<_>>()
|
|
.join(", ")
|
|
}
|
|
|
|
pub(super) fn build_sqlserver_table_select_sql(
|
|
table: &str,
|
|
where_clause: &str,
|
|
order_by: &str,
|
|
columns: &[String],
|
|
limit: usize,
|
|
offset: usize,
|
|
legacy_compatible: bool,
|
|
) -> String {
|
|
let columns_sql = if columns.is_empty() {
|
|
"*".to_string()
|
|
} else {
|
|
columns
|
|
.iter()
|
|
.map(|column| quote_table_identifier(Some(DatabaseType::SqlServer), column))
|
|
.collect::<Vec<_>>()
|
|
.join(", ")
|
|
};
|
|
let order = if order_by == "(SELECT NULL)" { String::new() } else { format!(" ORDER BY {order_by}") };
|
|
if legacy_compatible {
|
|
return format!("SELECT {columns_sql} FROM {table}{where_clause}{order}");
|
|
}
|
|
if offset == 0 {
|
|
return format!("SELECT TOP ({limit}) {columns_sql} FROM {table}{where_clause}{order}");
|
|
}
|
|
|
|
let page_alias = quote_table_identifier(Some(DatabaseType::SqlServer), "dbx_page");
|
|
let row_number_alias = quote_table_identifier(Some(DatabaseType::SqlServer), "__dbx_row_num");
|
|
let end = offset + limit;
|
|
format!(
|
|
"WITH {page_alias} AS (SELECT {columns_sql}, ROW_NUMBER() OVER (ORDER BY {order_by}) AS {row_number_alias} FROM {table}{where_clause}) SELECT {columns_sql} FROM {page_alias} WHERE {row_number_alias} > {offset} AND {row_number_alias} <= {end} ORDER BY {row_number_alias}"
|
|
)
|
|
}
|
|
|
|
pub(super) fn build_db2_table_select_page_sql(
|
|
table: &str,
|
|
where_clause: &str,
|
|
order_by: Option<&str>,
|
|
columns: &[String],
|
|
limit: usize,
|
|
offset: usize,
|
|
) -> String {
|
|
let columns_sql = if columns.is_empty() {
|
|
"*".to_string()
|
|
} else {
|
|
columns
|
|
.iter()
|
|
.map(|column| quote_table_identifier(Some(DatabaseType::Db2), column))
|
|
.collect::<Vec<_>>()
|
|
.join(", ")
|
|
};
|
|
let inner_columns = if columns.is_empty() {
|
|
"dbx_t.*".to_string()
|
|
} else {
|
|
columns
|
|
.iter()
|
|
.map(|column| format!("dbx_t.{}", quote_table_identifier(Some(DatabaseType::Db2), column)))
|
|
.collect::<Vec<_>>()
|
|
.join(", ")
|
|
};
|
|
let order = order_by.map(|order_by| format!("ORDER BY {order_by}")).unwrap_or_default();
|
|
let row_number = quote_table_identifier(Some(DatabaseType::Db2), "__dbx_row_num");
|
|
let end = offset + limit;
|
|
|
|
format!(
|
|
"SELECT {columns_sql} FROM (SELECT {inner_columns}, ROW_NUMBER() OVER ({order}) AS {row_number} FROM {table} dbx_t{where_clause}) dbx_page WHERE {row_number} > {offset} AND {row_number} <= {end} ORDER BY {row_number}"
|
|
)
|
|
}
|
|
|
|
/// Neo4j 5.0 replaced `id()` with `elementId()`, and servers before that only know `id()`, so the
|
|
/// generated Cypher has to pick the spelling the connected server accepts. An unknown version keeps
|
|
/// `elementId()`, which is what every caller without connection metadata got before.
|
|
pub fn neo4j_element_id_function(server_version: Option<&str>) -> &'static str {
|
|
match neo4j_major_version(server_version) {
|
|
Some(major) if major < NEO4J_ELEMENT_ID_MIN_MAJOR_VERSION => NEO4J_LEGACY_ELEMENT_ID_FUNCTION,
|
|
_ => "elementId",
|
|
}
|
|
}
|
|
|
|
/// The identity function Neo4j used before 5.0. Unlike `elementId()`, which returns a string, it
|
|
/// returns the node's internal `Integer` id, so callers comparing a value read from a grid have to
|
|
/// compare numbers.
|
|
pub const NEO4J_LEGACY_ELEMENT_ID_FUNCTION: &str = "id";
|
|
|
|
/// Extracts the leading `major` from version strings such as `4.4.44`, `Neo4j/5.26.0` or
|
|
/// `Neo4j/2025.01.0`. The product name itself contains a digit ("Neo4j"), so only a token that
|
|
/// *starts* with digits counts as the version. Anything without one is treated as unknown.
|
|
fn neo4j_major_version(server_version: Option<&str>) -> Option<u32> {
|
|
let version = server_version?.trim();
|
|
version.split(|character: char| !character.is_ascii_alphanumeric()).find_map(|token| {
|
|
let digits: String = token.chars().take_while(char::is_ascii_digit).collect();
|
|
if digits.is_empty() {
|
|
None
|
|
} else {
|
|
digits.parse().ok()
|
|
}
|
|
})
|
|
}
|
|
|
|
const NEO4J_ELEMENT_ID_MIN_MAJOR_VERSION: u32 = 5;
|
|
|
|
pub(super) fn build_neo4j_table_select_sql(options: &TableDataSelectSqlOptions, limit: usize) -> String {
|
|
let label = quote_table_identifier(Some(DatabaseType::Neo4j), &options.table_name);
|
|
let predicate = normalize_where_input(options.where_input.as_deref());
|
|
let where_clause = if predicate.is_empty() { String::new() } else { format!(" WHERE {predicate}") };
|
|
let returned_columns = if options.columns.is_empty() {
|
|
"n".to_string()
|
|
} else {
|
|
options
|
|
.columns
|
|
.iter()
|
|
.map(|column| {
|
|
let ident = quote_table_identifier(Some(DatabaseType::Neo4j), column);
|
|
format!("n.{ident} AS {ident}")
|
|
})
|
|
.collect::<Vec<_>>()
|
|
.join(", ")
|
|
};
|
|
let returns = format!(
|
|
"{}(n) AS {}, {returned_columns}",
|
|
neo4j_element_id_function(options.server_version.as_deref()),
|
|
quote_table_identifier(Some(DatabaseType::Neo4j), DBX_NEO4J_ELEMENT_ID_COLUMN)
|
|
);
|
|
let order_by = options.order_by.as_deref().filter(|order| !order.trim().is_empty());
|
|
let order = order_by.map(|order_by| format!(" ORDER BY {order_by}")).unwrap_or_default();
|
|
let skip = options.offset.filter(|offset| *offset > 0).map(|offset| format!(" SKIP {offset}")).unwrap_or_default();
|
|
format!("MATCH (n:{label}){where_clause} RETURN {returns}{order}{skip} LIMIT {limit};")
|
|
}
|
|
|
|
fn build_nebula_table_select_sql(options: &TableDataSelectSqlOptions, limit: usize) -> String {
|
|
let quote = |name: &str| quote_table_identifier(Some(DatabaseType::Nebula), name);
|
|
let kind = quote(&options.table_name);
|
|
let is_edge = options.table_type.as_deref().is_some_and(|kind| kind.eq_ignore_ascii_case("VIEW"));
|
|
let (pattern, identity, projection) = if is_edge {
|
|
let projection = if options.columns.is_empty() {
|
|
"e AS `edge`".to_string()
|
|
} else {
|
|
options
|
|
.columns
|
|
.iter()
|
|
.map(|column| format!("e.{} AS {}", quote(column), quote(column)))
|
|
.collect::<Vec<_>>()
|
|
.join(", ")
|
|
};
|
|
(format!("MATCH ()-[e:{kind}]->()"), "src(e) AS `_src`, dst(e) AS `_dst`, rank(e) AS `_rank`", projection)
|
|
} else {
|
|
let projection = if options.columns.is_empty() {
|
|
"v AS `vertex`".to_string()
|
|
} else {
|
|
options
|
|
.columns
|
|
.iter()
|
|
.map(|column| format!("v.{kind}.{} AS {}", quote(column), quote(column)))
|
|
.collect::<Vec<_>>()
|
|
.join(", ")
|
|
};
|
|
(format!("MATCH (v:{kind})"), "id(v) AS `_vid`", projection)
|
|
};
|
|
let predicate = normalize_where_input(options.where_input.as_deref());
|
|
let where_clause = if predicate.is_empty() { String::new() } else { format!(" WHERE {predicate}") };
|
|
let order = options
|
|
.order_by
|
|
.as_deref()
|
|
.filter(|order| !order.trim().is_empty())
|
|
.map(|order| format!(" ORDER BY {order}"))
|
|
.unwrap_or_default();
|
|
let skip = options.offset.filter(|offset| *offset > 0).map(|offset| format!(" SKIP {offset}")).unwrap_or_default();
|
|
format!("{pattern}{where_clause} RETURN {identity}, {projection}{order}{skip} LIMIT {limit};")
|
|
}
|
|
|
|
/// Salesforce's `FIELDS(ALL)` selector is only legal with a LIMIT of 200 or less.
|
|
const SALESFORCE_FIELDS_ALL_MAX_LIMIT: usize = 200;
|
|
|
|
/// Builds the SOQL used by the data-table grid for a Salesforce sObject.
|
|
///
|
|
/// SOQL is not SQL in three ways that matter here: there is no `SELECT *`, there
|
|
/// are no delimited identifiers (`FROM "Account"` is a `MALFORMED_QUERY`), and
|
|
/// the "everything" projection is the `FIELDS(ALL)` selector, which Salesforce
|
|
/// only accepts with `LIMIT 200` or less. Known fields are therefore projected
|
|
/// by name — that keeps any page size working — and `FIELDS(ALL)` is the capped
|
|
/// fallback for the callers that build SQL before the describe cache has loaded.
|
|
///
|
|
/// The statement carries no trailing semicolon: SOQL does not accept one.
|
|
pub(super) fn build_salesforce_table_select_sql(options: &TableDataSelectSqlOptions, limit: usize) -> String {
|
|
let object = options.table_name.trim();
|
|
let columns: Vec<&str> = options
|
|
.columns
|
|
.iter()
|
|
.map(String::as_str)
|
|
.map(str::trim)
|
|
.filter(|column| !column.is_empty() && !column.eq_ignore_ascii_case(DBX_ROWID_COLUMN))
|
|
.collect();
|
|
let (projection, effective_limit) = if columns.is_empty() {
|
|
("FIELDS(ALL)".to_string(), limit.min(SALESFORCE_FIELDS_ALL_MAX_LIMIT))
|
|
} else {
|
|
(columns.join(", "), limit)
|
|
};
|
|
// Passed through verbatim: a grid filter is the user's own predicate, and
|
|
// SOQL WHERE accepts the same parenthesised shape. Wrapping it in parentheses
|
|
// keeps a caller-supplied `OR` from binding outside the filter.
|
|
let predicate = normalize_where_input(options.where_input.as_deref());
|
|
let where_clause = if predicate.is_empty() { String::new() } else { format!(" WHERE ({predicate})") };
|
|
let order_by = options.order_by.as_deref().map(str::trim).filter(|order_by| !order_by.is_empty());
|
|
let order = order_by.map(|order_by| format!(" ORDER BY {order_by}")).unwrap_or_default();
|
|
// SOQL caps OFFSET at 2000 rows. Past that the org rejects the query, and
|
|
// surfacing its own error beats silently returning an earlier page.
|
|
let offset =
|
|
options.offset.filter(|offset| *offset > 0).map(|offset| format!(" OFFSET {offset}")).unwrap_or_default();
|
|
format!("SELECT {projection} FROM {object}{where_clause}{order} LIMIT {effective_limit}{offset}")
|
|
}
|
|
|
|
pub(super) fn build_questdb_table_select_sql(
|
|
table: &str,
|
|
where_clause: &str,
|
|
order_by: &str,
|
|
columns: &[String],
|
|
limit: usize,
|
|
offset: usize,
|
|
) -> String {
|
|
let columns_sql = if columns.is_empty() {
|
|
"*".to_string()
|
|
} else {
|
|
columns
|
|
.iter()
|
|
.map(|column| quote_table_identifier(Some(DatabaseType::Questdb), column))
|
|
.collect::<Vec<_>>()
|
|
.join(", ")
|
|
};
|
|
if offset == 0 {
|
|
return format!("SELECT {columns_sql} FROM {table}{where_clause}{order_by} LIMIT {limit}");
|
|
}
|
|
let upper_bound = offset + limit;
|
|
format!("SELECT {columns_sql} FROM {table}{where_clause}{order_by} LIMIT {offset}, {upper_bound}")
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
fn opts(
|
|
database_type: DatabaseType,
|
|
catalog: Option<&str>,
|
|
database: Option<&str>,
|
|
table: &str,
|
|
) -> TableDataSelectSqlOptions {
|
|
TableDataSelectSqlOptions {
|
|
database_type: Some(database_type),
|
|
driver_profile: None,
|
|
identifier_quote: None,
|
|
server_version: None,
|
|
schema: None,
|
|
table_name: table.to_string(),
|
|
catalog: catalog.map(|c| c.to_string()),
|
|
database: database.map(|d| d.to_string()),
|
|
table_type: None,
|
|
primary_keys: Vec::new(),
|
|
columns: Vec::new(),
|
|
column_types: Vec::new(),
|
|
large_value_preview_size: None,
|
|
fallback_order_columns: Vec::new(),
|
|
order_by: None,
|
|
limit: Some(10),
|
|
offset: None,
|
|
use_driver_row_offset: false,
|
|
where_input: None,
|
|
inject_default_time_series_where: false,
|
|
include_row_id: false,
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn influxdb_table_select_uses_star_and_rolling_window() {
|
|
// InfluxDB tables can carry dozens of tags/fields; enumerating them
|
|
// all in the SELECT list produces an unreadable wall of names.
|
|
// Emit `SELECT *` (InfluxQL supports it natively) and inject a
|
|
// rolling five-minute WHERE so the query stays cheap on production
|
|
// data. Users can narrow the projection or widen the window by
|
|
// editing the generated SQL.
|
|
assert_eq!(
|
|
build_table_data_select_sql(TableDataSelectSqlOptions {
|
|
database_type: Some(DatabaseType::InfluxDb),
|
|
database: Some("monitor".to_string()),
|
|
table_name: "cpu".to_string(),
|
|
columns: vec!["time".to_string(), "host".to_string(), "value".to_string()],
|
|
inject_default_time_series_where: true,
|
|
..Default::default()
|
|
}),
|
|
"SELECT * FROM \"cpu\" WHERE (time > now() - 5m) ORDER BY time DESC LIMIT 100;"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn influxdb3_table_select_injects_datafusion_interval() {
|
|
// InfluxDB 3.x runs DataFusion SQL, which needs ANSI INTERVAL
|
|
// literals rather than InfluxQL's Go-style duration form.
|
|
assert_eq!(
|
|
build_table_data_select_sql(TableDataSelectSqlOptions {
|
|
database_type: Some(DatabaseType::InfluxDb3),
|
|
database: Some("monitor".to_string()),
|
|
table_name: "cpu".to_string(),
|
|
inject_default_time_series_where: true,
|
|
..Default::default()
|
|
}),
|
|
"SELECT * FROM \"cpu\" WHERE (time > now() - INTERVAL '5 minutes') ORDER BY time DESC LIMIT 100;"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn influxdb_table_select_without_opt_in_stays_unfiltered() {
|
|
// Sampling (agent_tools) and whole-table export (csv_export) build
|
|
// SQL without the opt-in flag and must keep the historical
|
|
// unbounded scan semantics.
|
|
let sql = build_table_data_select_sql(TableDataSelectSqlOptions {
|
|
database_type: Some(DatabaseType::InfluxDb),
|
|
database: Some("monitor".to_string()),
|
|
table_name: "cpu".to_string(),
|
|
..Default::default()
|
|
});
|
|
assert!(!sql.contains("WHERE"), "unexpected default WHERE in non-opt-in SQL: {sql}");
|
|
}
|
|
|
|
#[test]
|
|
fn influxdb_table_select_honors_user_supplied_where() {
|
|
// When the caller passes their own predicate the default window is
|
|
// dropped — otherwise widening the range would require a new option.
|
|
assert_eq!(
|
|
build_table_data_select_sql(TableDataSelectSqlOptions {
|
|
database_type: Some(DatabaseType::InfluxDb),
|
|
database: Some("monitor".to_string()),
|
|
table_name: "cpu".to_string(),
|
|
where_input: Some("host = 'web-01'".to_string()),
|
|
..Default::default()
|
|
}),
|
|
"SELECT * FROM \"cpu\" WHERE (host = 'web-01') ORDER BY time DESC LIMIT 100;"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn non_time_series_engines_get_no_default_where() {
|
|
// The rolling-window default is scoped to time-series engines; other
|
|
// dialects keep their historical unfiltered behavior.
|
|
let sql = build_table_data_select_sql(TableDataSelectSqlOptions {
|
|
database_type: Some(DatabaseType::Postgres),
|
|
schema: Some("public".to_string()),
|
|
table_name: "orders".to_string(),
|
|
..Default::default()
|
|
});
|
|
assert!(!sql.contains("WHERE"), "unexpected WHERE in non-time-series SQL: {sql}");
|
|
}
|
|
|
|
#[test]
|
|
fn databricks_table_select_uses_unity_catalog_three_part_name() {
|
|
let explicit_catalog = TableDataSelectSqlOptions {
|
|
database_type: Some(DatabaseType::Databricks),
|
|
catalog: Some("analytics".to_string()),
|
|
database: Some("ignored_tree_catalog".to_string()),
|
|
schema: Some("sales".to_string()),
|
|
table_name: "orders".to_string(),
|
|
limit: Some(100),
|
|
..Default::default()
|
|
};
|
|
assert_eq!(
|
|
build_table_data_select_sql(explicit_catalog),
|
|
"SELECT * FROM `analytics`.`sales`.`orders` LIMIT 100;"
|
|
);
|
|
|
|
let tree_catalog = TableDataSelectSqlOptions {
|
|
database_type: Some(DatabaseType::Databricks),
|
|
database: Some("analytics".to_string()),
|
|
schema: Some("sales".to_string()),
|
|
table_name: "orders".to_string(),
|
|
limit: Some(100),
|
|
..Default::default()
|
|
};
|
|
assert_eq!(build_table_data_select_sql(tree_catalog), "SELECT * FROM `analytics`.`sales`.`orders` LIMIT 100;");
|
|
}
|
|
|
|
#[test]
|
|
fn databricks_table_select_without_catalog_keeps_two_part_name() {
|
|
assert_eq!(
|
|
build_table_data_select_sql(TableDataSelectSqlOptions {
|
|
database_type: Some(DatabaseType::Databricks),
|
|
schema: Some("sales".to_string()),
|
|
table_name: "ads_veeva_target_customer_df".to_string(),
|
|
limit: Some(100),
|
|
..Default::default()
|
|
}),
|
|
"SELECT * FROM `sales`.`ads_veeva_target_customer_df` LIMIT 100;"
|
|
);
|
|
assert_eq!(
|
|
build_table_data_select_sql(TableDataSelectSqlOptions {
|
|
database_type: Some(DatabaseType::Databricks),
|
|
identifier_quote: Some("\"".to_string()),
|
|
schema: Some("sales`west".to_string()),
|
|
table_name: "ads`target".to_string(),
|
|
limit: Some(100),
|
|
..Default::default()
|
|
}),
|
|
"SELECT * FROM `sales``west`.`ads``target` LIMIT 100;"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn doris_external_catalog_prefixes_from_clause() {
|
|
let sql =
|
|
build_table_data_select_sql(opts(DatabaseType::Doris, Some("iceberg_catalog"), Some("sales"), "orders"));
|
|
assert!(sql.contains("FROM `iceberg_catalog`.`sales`.`orders`"), "sql was: {sql}");
|
|
}
|
|
|
|
#[test]
|
|
fn starrocks_external_catalog_prefixes_from_clause() {
|
|
let sql =
|
|
build_table_data_select_sql(opts(DatabaseType::StarRocks, Some("hive_catalog"), Some("sales"), "orders"));
|
|
assert!(sql.contains("FROM `hive_catalog`.`sales`.`orders`"), "sql was: {sql}");
|
|
}
|
|
|
|
#[test]
|
|
fn table_data_select_optionally_qualifies_database() {
|
|
let options = opts(DatabaseType::Mysql, None, Some("aaa"), "apis");
|
|
assert_eq!(build_table_data_select_sql(options.clone()), "SELECT * FROM `apis` LIMIT 10;");
|
|
assert_eq!(build_table_data_select_sql_with_database(options, true), "SELECT * FROM `aaa`.`apis` LIMIT 10;");
|
|
}
|
|
|
|
/// issue #9262: SQL Server addresses tables as `database.schema.table`, and
|
|
/// the grid label must reach the three-part form once the user opted into
|
|
/// `生成 SQL 时包含数据库名`.
|
|
#[test]
|
|
fn sqlserver_table_data_select_optionally_qualifies_database() {
|
|
let options = TableDataSelectSqlOptions {
|
|
database_type: Some(DatabaseType::SqlServer),
|
|
schema: Some("dbo".to_string()),
|
|
database: Some("dbx".to_string()),
|
|
table_name: "AcceptanceProductLog".to_string(),
|
|
limit: Some(100),
|
|
..Default::default()
|
|
};
|
|
assert_eq!(
|
|
build_table_data_select_sql(options.clone()),
|
|
"SELECT TOP (100) * FROM [dbo].[AcceptanceProductLog]"
|
|
);
|
|
assert_eq!(
|
|
build_table_data_select_sql_with_database(options, true),
|
|
"SELECT TOP (100) * FROM [dbx].[dbo].[AcceptanceProductLog]"
|
|
);
|
|
}
|
|
|
|
/// A linked-server schema already encodes `server|catalog|schema`; the local
|
|
/// database must never be prefixed on top of it.
|
|
#[test]
|
|
fn sqlserver_linked_schema_ignores_include_database_name() {
|
|
let options = TableDataSelectSqlOptions {
|
|
database_type: Some(DatabaseType::SqlServer),
|
|
schema: Some("__dbx_sqlserver_linked__:ERP|Finance|dbo".to_string()),
|
|
database: Some("dbx".to_string()),
|
|
table_name: "orders".to_string(),
|
|
limit: Some(100),
|
|
..Default::default()
|
|
};
|
|
let sql = build_table_data_select_sql_with_database(options, true);
|
|
assert_eq!(sql, "SELECT TOP (100) * FROM [ERP].[Finance].[dbo].[orders]");
|
|
}
|
|
|
|
/// `database_qualified_table_name` is shared by every generated-SQL surface,
|
|
/// so pin its per-engine contract directly.
|
|
#[test]
|
|
fn database_qualified_table_name_matches_engine_naming() {
|
|
assert_eq!(
|
|
database_qualified_table_name(Some(DatabaseType::Mysql), None, None, Some("dbx"), "t").as_deref(),
|
|
Some("`dbx`.`t`")
|
|
);
|
|
// A cross-database editable result keeps its own namespace, not the
|
|
// connection's default database.
|
|
assert_eq!(
|
|
database_qualified_table_name(Some(DatabaseType::Mysql), None, Some("db_9"), Some("dbx"), "t").as_deref(),
|
|
Some("`db_9`.`t`")
|
|
);
|
|
assert_eq!(
|
|
database_qualified_table_name(Some(DatabaseType::ClickHouse), None, Some("default"), Some("dbx"), "t")
|
|
.as_deref(),
|
|
Some("`dbx`.`t`")
|
|
);
|
|
assert_eq!(
|
|
database_qualified_table_name(Some(DatabaseType::SqlServer), None, Some("dbo"), Some("dbx"), "t")
|
|
.as_deref(),
|
|
Some("[dbx].[dbo].[t]")
|
|
);
|
|
// SQL Server without a schema cannot build a valid three-part name.
|
|
assert_eq!(database_qualified_table_name(Some(DatabaseType::SqlServer), None, None, Some("dbx"), "t"), None);
|
|
assert_eq!(
|
|
database_qualified_table_name(Some(DatabaseType::Postgres), None, Some("public"), Some("dbx"), "t"),
|
|
None
|
|
);
|
|
assert_eq!(database_qualified_table_name(Some(DatabaseType::Mysql), None, None, None, "t"), None);
|
|
}
|
|
|
|
#[test]
|
|
fn doris_external_catalog_without_database_degrades_to_two_part() {
|
|
// When neither schema nor database is provided the name degrades to the
|
|
// 2-part `catalog.table` form.
|
|
let sql = build_table_data_select_sql(opts(DatabaseType::Doris, Some("iceberg_catalog"), None, "orders"));
|
|
assert!(sql.contains("FROM `iceberg_catalog`.`orders`"), "sql was: {sql}");
|
|
}
|
|
|
|
#[test]
|
|
fn doris_internal_catalog_is_not_prefixed() {
|
|
let sql = build_table_data_select_sql(opts(DatabaseType::Doris, Some("internal"), None, "orders"));
|
|
assert!(!sql.contains("internal"), "sql was: {sql}");
|
|
assert!(sql.contains("FROM `orders`"), "sql was: {sql}");
|
|
}
|
|
|
|
#[test]
|
|
fn doris_empty_catalog_is_not_prefixed() {
|
|
let sql = build_table_data_select_sql(opts(DatabaseType::Doris, Some(" "), None, "orders"));
|
|
assert!(sql.contains("FROM `orders`"), "sql was: {sql}");
|
|
}
|
|
|
|
#[test]
|
|
fn doris_no_catalog_is_not_prefixed() {
|
|
let sql = build_table_data_select_sql(opts(DatabaseType::Doris, None, None, "orders"));
|
|
assert!(sql.contains("FROM `orders`"), "sql was: {sql}");
|
|
}
|
|
|
|
#[test]
|
|
fn catalog_qualification_does_not_change_other_dialects() {
|
|
// Postgres does not support the 3-part catalog naming; the catalog
|
|
// must be ignored to avoid emitting an invalid qualified name.
|
|
let sql = build_table_data_select_sql(TableDataSelectSqlOptions {
|
|
database_type: Some(DatabaseType::Postgres),
|
|
catalog: Some("analytics".to_string()),
|
|
database: Some("warehouse".to_string()),
|
|
schema: Some("sales".to_string()),
|
|
table_name: "orders".to_string(),
|
|
limit: Some(10),
|
|
..Default::default()
|
|
});
|
|
assert_eq!(sql, "SELECT * FROM \"sales\".\"orders\" LIMIT 10;");
|
|
}
|
|
|
|
#[test]
|
|
fn victoriametrics_builds_metric_queries_without_sql_identifiers() {
|
|
assert_eq!(
|
|
build_table_data_select_sql(opts(DatabaseType::VictoriaMetrics, None, None, "rack_temperature")),
|
|
r#"{__name__="rack_temperature"}[1h]"#
|
|
);
|
|
assert_eq!(
|
|
build_count_table_sql(Some(DatabaseType::VictoriaMetrics), None, "rack\\\"temperature"),
|
|
r#"count({__name__="rack\\\"temperature"})"#
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn sqlserver_legacy_table_preview_leaves_paging_to_the_agent_cursor() {
|
|
let mut options = opts(DatabaseType::SqlServer, None, None, "users");
|
|
options.driver_profile = Some(" SQLSERVER-LEGACY ".to_string());
|
|
options.columns = vec!["id".to_string(), "name".to_string()];
|
|
options.order_by = Some("[id] ASC".to_string());
|
|
options.limit = Some(100);
|
|
options.offset = Some(100);
|
|
|
|
assert_eq!(build_table_data_select_sql(options), "SELECT [id], [name] FROM [users] ORDER BY [id] ASC");
|
|
}
|
|
|
|
#[test]
|
|
fn salesforce_table_select_projects_described_fields_as_soql() {
|
|
// SOQL has no `SELECT *` and no delimited identifiers, so the ANSI shape the
|
|
// grid used to emit (`SELECT * FROM "Account" LIMIT 100`) fails twice over:
|
|
// the star is not a SOQL selector and the quote is read as a string literal,
|
|
// which Salesforce reports as MALFORMED_QUERY at column 14. Fields from the
|
|
// describe go out bare and by name. No trailing semicolon either — SOQL
|
|
// rejects one.
|
|
let mut options = opts(DatabaseType::Salesforce, Some("sales"), Some("org"), "Account");
|
|
options.columns = vec!["Id".to_string(), "Name".to_string(), "First_Name__c".to_string()];
|
|
options.limit = Some(100);
|
|
|
|
// A Salesforce org is a single scope: schema/database qualification has no
|
|
// SOQL spelling and would land in the FROM clause as a parse error.
|
|
assert_eq!(build_table_data_select_sql(options), "SELECT Id, Name, First_Name__c FROM Account LIMIT 100");
|
|
}
|
|
|
|
#[test]
|
|
fn salesforce_table_select_caps_the_fields_all_fallback() {
|
|
// Callers that build SQL before the describe cache has loaded have no field
|
|
// list. `FIELDS(ALL)` is the SOQL "everything" projection, but Salesforce
|
|
// only accepts it with LIMIT 200 or less, so a larger page size is clamped
|
|
// instead of being sent as a query the org would refuse outright.
|
|
assert_eq!(
|
|
build_table_data_select_sql(TableDataSelectSqlOptions {
|
|
database_type: Some(DatabaseType::Salesforce),
|
|
table_name: "Account".to_string(),
|
|
limit: Some(1000),
|
|
..Default::default()
|
|
}),
|
|
"SELECT FIELDS(ALL) FROM Account LIMIT 200"
|
|
);
|
|
assert_eq!(
|
|
build_table_data_select_sql(TableDataSelectSqlOptions {
|
|
database_type: Some(DatabaseType::Salesforce),
|
|
table_name: "Account".to_string(),
|
|
..Default::default()
|
|
}),
|
|
"SELECT FIELDS(ALL) FROM Account LIMIT 100"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn salesforce_table_select_keeps_an_explicit_projection_at_any_page_size() {
|
|
// The 200-row clamp is a property of FIELDS(), not of SOQL: naming the
|
|
// fields keeps a 1000-row page legal.
|
|
let mut options = opts(DatabaseType::Salesforce, None, None, "Account");
|
|
options.columns = vec!["Id".to_string(), "Name".to_string()];
|
|
options.limit = Some(1000);
|
|
|
|
assert_eq!(build_table_data_select_sql(options), "SELECT Id, Name FROM Account LIMIT 1000");
|
|
}
|
|
|
|
#[test]
|
|
fn salesforce_table_select_composes_filter_order_and_offset() {
|
|
let mut options = opts(DatabaseType::Salesforce, None, None, "Account");
|
|
options.columns = vec!["Id".to_string(), "Name".to_string()];
|
|
options.where_input = Some("WHERE Industry = 'Energy' OR AnnualRevenue > 0".to_string());
|
|
options.order_by = Some("Name ASC".to_string());
|
|
options.limit = Some(50);
|
|
options.offset = Some(150);
|
|
|
|
// The leading WHERE is stripped and the predicate is parenthesised so a
|
|
// caller-supplied OR cannot bind outside the grid filter.
|
|
assert_eq!(
|
|
build_table_data_select_sql(options),
|
|
"SELECT Id, Name FROM Account WHERE (Industry = 'Energy' OR AnnualRevenue > 0) ORDER BY Name ASC LIMIT 50 OFFSET 150"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn salesforce_table_select_drops_the_synthetic_row_id() {
|
|
// The grid's synthetic row-id column is a DBX artifact for drivers without a
|
|
// primary key; it is not an sObject field, so projecting it would be an
|
|
// invalid field name in SOQL.
|
|
let mut options = opts(DatabaseType::Salesforce, None, None, "Account");
|
|
options.columns = vec!["Id".to_string(), DBX_ROWID_COLUMN.to_string()];
|
|
options.include_row_id = true;
|
|
|
|
assert_eq!(build_table_data_select_sql(options), "SELECT Id FROM Account LIMIT 10");
|
|
}
|
|
}
|