use chrono::{NaiveDate, NaiveDateTime, NaiveTime}; use futures::StreamExt; use mysql_async::consts::ColumnType; use mysql_async::prelude::*; use percent_encoding::percent_decode_str; use rust_decimal::Decimal; use std::borrow::Cow; use std::collections::HashSet; use std::path::PathBuf; use std::time::Duration; use std::time::Instant; use crate::sql::starts_with_executable_sql_keyword; use crate::types::{ ColumnInfo, DatabaseInfo, ForeignKeyInfo, IndexInfo, ObjectInfo, QueryResult, TableInfo, TriggerInfo, }; use super::file_validator::validate_file_path; pub type MySqlPool = mysql_async::Pool; fn quote_value(s: &str) -> String { format!("'{}'", s.replace('\\', "\\\\").replace('\'', "\\'")) } fn row_get(row: &mysql_async::Row, index: I) -> Option where T: mysql_async::prelude::FromValue, I: mysql_async::prelude::ColumnIndex, { row.get_opt::(index).and_then(|result| result.ok()) } fn get_str(row: &mysql_async::Row, idx: usize) -> String { row_get::(row, idx) .or_else(|| row_get::, _>(row, idx).map(|b| String::from_utf8_lossy(&b).to_string())) .unwrap_or_default() } fn get_str_by_name(row: &mysql_async::Row, name: &str) -> String { row_get::(row, name) .or_else(|| row_get::, _>(row, name).map(|b| String::from_utf8_lossy(&b).to_string())) .unwrap_or_default() } fn get_opt_str(row: &mysql_async::Row, name: &str) -> Option { row_get::(row, name) .or_else(|| row_get::, _>(row, name).map(|b| String::from_utf8_lossy(&b).to_string())) } fn numeric_metadata_u64_to_i32(value: Option) -> Option { value.and_then(|v| i32::try_from(v).ok()) } fn numeric_metadata_i64_to_i32(value: Option) -> Option { value.and_then(|v| i32::try_from(v).ok()) } fn numeric_metadata_str_to_i32(value: Option) -> Option { value.and_then(|v| v.parse::().ok()).and_then(|v| i32::try_from(v).ok()) } fn get_opt_i32(row: &mysql_async::Row, name: &str) -> Option { row_get::(row, name) .or_else(|| numeric_metadata_i64_to_i32(row_get::(row, name))) .or_else(|| numeric_metadata_u64_to_i32(row_get::(row, name))) .or_else(|| numeric_metadata_str_to_i32(row_get::(row, name))) .or_else(|| { row_get::, _>(row, name) .and_then(|b| String::from_utf8(b).ok()) .and_then(|v| numeric_metadata_str_to_i32(Some(v))) }) } #[cfg(test)] fn mysql_datetime_to_string(value: NaiveDateTime) -> String { value.to_string() } #[cfg(test)] fn is_mysql_lossless_integer_type(type_name: &str) -> bool { let upper_type = type_name.to_uppercase(); upper_type.contains("BIGINT") || upper_type.contains("LARGEINT") } fn is_lossless_integer_column(column: &mysql_async::Column) -> bool { matches!(column.column_type(), ColumnType::MYSQL_TYPE_LONGLONG | ColumnType::MYSQL_TYPE_NEWDECIMAL) } fn is_mysql_binary_charset(column: &mysql_async::Column) -> bool { column.character_set() == 63 } fn is_mysql_blob_column(column: &mysql_async::Column) -> bool { is_mysql_binary_charset(column) && matches!( column.column_type(), ColumnType::MYSQL_TYPE_BLOB | ColumnType::MYSQL_TYPE_LONG_BLOB | ColumnType::MYSQL_TYPE_MEDIUM_BLOB | ColumnType::MYSQL_TYPE_TINY_BLOB ) } fn is_mysql_binary_string_column(column: &mysql_async::Column) -> bool { is_mysql_binary_charset(column) && matches!( column.column_type(), ColumnType::MYSQL_TYPE_STRING | ColumnType::MYSQL_TYPE_VAR_STRING | ColumnType::MYSQL_TYPE_VARCHAR ) } fn mysql_printable_binary_preview(bytes: &[u8]) -> Option { let trimmed = bytes.strip_suffix(&[0]).map_or(bytes, |mut value| { while let Some(rest) = value.strip_suffix(&[0]) { value = rest; } value }); if trimmed.is_empty() { return Some(String::new()); } let text = std::str::from_utf8(trimmed).ok()?; text.chars().all(|ch| !ch.is_control() || matches!(ch, '\t' | '\n' | '\r')).then(|| text.to_string()) } fn mysql_blob_preview(bytes: &[u8], label: &str) -> serde_json::Value { serde_json::Value::String(format!("({label}) {} bytes", bytes.len())) } fn mysql_bit_value_to_string(bytes: &[u8], column: &mysql_async::Column) -> String { let bit_len = column.column_length(); if bit_len > 1 { let total_bits = bytes.len() * 8; let mut bits = String::with_capacity(total_bits); for byte in bytes { bits.push_str(&format!("{byte:08b}")); } let start = bits.len().saturating_sub(bit_len as usize); return bits[start..].to_string(); } let val = bytes.iter().fold(0u64, |acc, &b| (acc << 8) | b as u64); val.to_string() } fn mysql_bytes_to_json(bytes: Vec, column: &mysql_async::Column) -> serde_json::Value { if is_mysql_blob_column(column) { return mysql_blob_preview(&bytes, "BLOB"); } if is_mysql_binary_string_column(column) { return mysql_printable_binary_preview(&bytes) .map(serde_json::Value::String) .unwrap_or_else(|| super::binary_value_to_json(&bytes)); } serde_json::Value::String(String::from_utf8_lossy(&bytes).to_string()) } fn mysql_value_to_json(row: &mysql_async::Row, idx: usize) -> serde_json::Value { let Some(column) = row.columns_ref().get(idx) else { return serde_json::Value::Null; }; let Some(value) = row.as_ref(idx) else { return serde_json::Value::Null; }; if matches!(value, mysql_async::Value::NULL) { return serde_json::Value::Null; } if is_mysql_binary_string_column(column) { return row_get::, _>(row, idx) .map(|bytes| mysql_bytes_to_json(bytes, column)) .unwrap_or(serde_json::Value::Null); } match column.column_type() { ColumnType::MYSQL_TYPE_JSON => { if let Some(v) = row_get::(row, idx) { return serde_json::Value::String(v); } } ColumnType::MYSQL_TYPE_DECIMAL | ColumnType::MYSQL_TYPE_NEWDECIMAL | ColumnType::MYSQL_TYPE_LONGLONG => { if is_lossless_integer_column(column) { return row .get_opt::(idx) .and_then(|result| result.ok()) .map(serde_json::Value::String) .or_else(|| { row_get::(row, idx).map(|v: Decimal| serde_json::Value::String(v.to_string())) }) .or_else(|| row_get::(row, idx).map(|v| serde_json::Value::String(v.to_string()))) .or_else(|| row_get::(row, idx).map(|v| serde_json::Value::String(v.to_string()))) .or_else(|| row_get::, _>(row, idx).map(|bytes| mysql_bytes_to_json(bytes, column))) .unwrap_or(serde_json::Value::Null); } return row .get_opt::(idx) .and_then(|result| result.ok()) .map(|v: Decimal| serde_json::Value::String(v.to_string())) .unwrap_or(serde_json::Value::Null); } ColumnType::MYSQL_TYPE_BIT => { return row_get::, _>(row, idx) .map(|bytes| serde_json::Value::String(mysql_bit_value_to_string(&bytes, column))) .unwrap_or(serde_json::Value::Null); } ColumnType::MYSQL_TYPE_BLOB | ColumnType::MYSQL_TYPE_LONG_BLOB | ColumnType::MYSQL_TYPE_MEDIUM_BLOB | ColumnType::MYSQL_TYPE_TINY_BLOB | ColumnType::MYSQL_TYPE_GEOMETRY => { return row_get::, _>(row, idx) .map(|bytes| { if matches!(column.column_type(), ColumnType::MYSQL_TYPE_GEOMETRY) { mysql_blob_preview(&bytes, "GEOMETRY") } else { mysql_bytes_to_json(bytes, column) } }) .unwrap_or(serde_json::Value::Null); } ColumnType::MYSQL_TYPE_TIMESTAMP | ColumnType::MYSQL_TYPE_TIMESTAMP2 | ColumnType::MYSQL_TYPE_DATETIME | ColumnType::MYSQL_TYPE_DATETIME2 | ColumnType::MYSQL_TYPE_DATE | ColumnType::MYSQL_TYPE_TIME | ColumnType::MYSQL_TYPE_TIME2 | ColumnType::MYSQL_TYPE_NEWDATE => { if let Some(v) = row_get::(row, idx) { return serde_json::Value::String(v.to_string()); } if let Some(v) = row_get::(row, idx) { return serde_json::Value::String(v.to_string()); } if let Some(v) = row_get::(row, idx) { return serde_json::Value::String(v.to_string()); } } _ => {} } row_get::(row, idx) .map(serde_json::Value::String) .or_else(|| row_get::(row, idx).map(super::safe_i64_to_json)) .or_else(|| row_get::(row, idx).map(super::safe_u64_to_json)) .or_else(|| row_get::(row, idx).map(|v| serde_json::Value::Number(v.into()))) .or_else(|| row_get::(row, idx).map(|v| serde_json::Value::Number(v.into()))) .or_else(|| { row_get::(row, idx).map(|v| { serde_json::Number::from_f64(v).map(serde_json::Value::Number).unwrap_or(serde_json::Value::Null) }) }) .or_else(|| row_get::(row, idx).map(serde_json::Value::Bool)) .or_else(|| row_get::, _>(row, idx).map(|bytes| mysql_bytes_to_json(bytes, column))) .unwrap_or(serde_json::Value::Null) } pub async fn connect(url: &str, fallback_timeout: Duration) -> Result { connect_with_ca_cert(url, None, fallback_timeout).await } pub async fn connect_with_ca_cert( url: &str, ca_cert_path: Option<&str>, fallback_timeout: Duration, ) -> Result { let timeout = super::parse_connect_timeout_with_fallback(url, fallback_timeout); let pool = create_pool(url, ca_cert_path)?; let result = verify_pool_connection(&pool, timeout).await; if let Err(ref e) = result { if mysql_error_should_retry_without_ssl(e) { if let Some(fallback_url) = ssl_fallback_url(url) { log::info!("SSL handshake failed, retrying with ssl-mode=disabled"); let fallback_pool = create_pool(&fallback_url, None)?; return match verify_pool_connection(&fallback_pool, timeout).await { Ok(()) => Ok(fallback_pool), Err(e) => Err(e), }; } } } result.map(|_| pool) } #[derive(Debug, Default, Clone, PartialEq, Eq)] struct MySqlTlsFiles { sslcert: Option, sslkey: Option, } fn create_pool(url: &str, ca_cert_path: Option<&str>) -> Result { let tls_url = mysql_tls_url(url)?; let opts = mysql_async::Opts::from_url(&mysql_async_url(&tls_url.url)).map_err(|e| format!("Invalid MySQL URL: {e}"))?; let base_ssl_opts = opts.ssl_opts().cloned(); let pool_opts = mysql_async::PoolOpts::new() .with_constraints(mysql_async::PoolConstraints::new(1, 1).unwrap()) .with_inactive_connection_ttl(Duration::from_secs(300)); let mut builder = mysql_async::OptsBuilder::from_opts(opts) .stmt_cache_size(0) .prefer_socket(false) .pool_opts(Some(pool_opts)) .setup(mysql_setup_queries(url)); if let Some(ssl_opts) = mysql_ssl_opts(base_ssl_opts, url, ca_cert_path, &tls_url.files)? { builder = builder.ssl_opts(ssl_opts); } Ok(MySqlPool::new(builder)) } #[derive(Debug, Clone, PartialEq, Eq)] struct MySqlTlsUrl { url: String, files: MySqlTlsFiles, } fn mysql_tls_url(url: &str) -> Result { let Some(query_start) = url.find('?') else { return Ok(MySqlTlsUrl { url: url.to_string(), files: MySqlTlsFiles::default() }); }; let prefix = &url[..query_start]; let suffix = &url[query_start + 1..]; let (query_string, fragment) = suffix.split_once('#').map_or((suffix, ""), |(query, fragment)| (query, fragment)); let mut files = MySqlTlsFiles::default(); let mut kept_params = Vec::new(); for param in query_string.split('&') { if param.is_empty() { continue; } let Some((key, value)) = param.split_once('=') else { kept_params.push(param.to_string()); continue; }; if mysql_tls_file_param_is(key, "cert") || mysql_tls_file_param_is(key, "key") { let decoded = percent_decode_str(value) .decode_utf8() .map_err(|_| format!("Invalid URL encoding in {key}"))? .into_owned(); validate_file_path(&decoded, |_| false).map_err(|e| format!("{key}: {e}"))?; if mysql_tls_file_param_is(key, "cert") { files.sslcert = Some(decoded); } else { files.sslkey = Some(decoded); } } else { kept_params.push(param.to_string()); } } let mut sanitized_url = prefix.to_string(); if !kept_params.is_empty() { sanitized_url.push('?'); sanitized_url.push_str(&kept_params.join("&")); } if !fragment.is_empty() { sanitized_url.push('#'); sanitized_url.push_str(fragment); } Ok(MySqlTlsUrl { url: sanitized_url, files }) } fn mysql_tls_file_param_is(key: &str, target: &str) -> bool { let normalized = key.to_ascii_lowercase().replace(['-', '_'], ""); normalized == format!("ssl{target}") } fn mysql_ssl_opts( base_ssl_opts: Option, url: &str, ca_cert_path: Option<&str>, files: &MySqlTlsFiles, ) -> Result, String> { let ca_cert_path = ca_cert_path.map(str::trim).filter(|path| !path.is_empty()); let has_client_identity = files.sslcert.as_deref().is_some() || files.sslkey.as_deref().is_some(); if !mysql_url_requires_ssl(url) && !has_client_identity { return Ok(None); } let mut ssl_opts = base_ssl_opts.unwrap_or_default(); if let Some(ca_cert_path) = ca_cert_path.filter(|_| mysql_url_requires_ssl(url) || has_client_identity) { ssl_opts = ssl_opts.with_root_certs(vec![PathBuf::from(ca_cert_path).into()]); if !mysql_url_verifies_identity(url) { ssl_opts = ssl_opts.with_danger_skip_domain_validation(true); } } match (files.sslcert.as_deref(), files.sslkey.as_deref()) { (Some(cert_path), Some(key_path)) => { ssl_opts = ssl_opts.with_client_identity(Some(mysql_async::ClientIdentity::new( PathBuf::from(cert_path).into(), PathBuf::from(key_path).into(), ))); } (Some(_), None) => return Err("MySQL ssl-cert requires ssl-key".to_string()), (None, Some(_)) => return Err("MySQL ssl-key requires ssl-cert".to_string()), (None, None) => {} } Ok(Some(ssl_opts)) } fn mysql_setup_queries(url: &str) -> Vec { let charset = mysql_connection_charset(url).unwrap_or("utf8mb4"); vec![format!("SET NAMES {charset}")] } fn should_enable_explicit_timestamp_defaults(sql: &str) -> bool { if !starts_with_executable_sql_keyword(sql, &["CREATE", "ALTER"]) { return false; } let lower = sql.split_whitespace().collect::>().join(" ").to_ascii_lowercase(); lower.contains("timestamp") && lower.contains("default null") } fn explicit_timestamp_defaults_sql(enabled: bool) -> &'static str { if enabled { "SET SESSION explicit_defaults_for_timestamp = ON" } else { "SET SESSION explicit_defaults_for_timestamp = OFF" } } async fn enable_explicit_timestamp_defaults_for_query(conn: &mut mysql_async::Conn, sql: &str) -> Option { if !should_enable_explicit_timestamp_defaults(sql) { return None; } let previous = match conn.query_first::("SELECT @@SESSION.explicit_defaults_for_timestamp").await { Ok(Some(value)) => value != 0, Ok(None) => { log::debug!("Skipping MySQL explicit timestamp defaults compatibility setting: variable was empty"); return None; } Err(err) => { log::debug!("Skipping MySQL explicit timestamp defaults compatibility setting: {err}"); return None; } }; if previous { return None; } if let Err(err) = conn.query_drop(explicit_timestamp_defaults_sql(true)).await { log::debug!("Skipping MySQL explicit timestamp defaults compatibility setting: {err}"); return None; } Some(previous) } async fn restore_explicit_timestamp_defaults_for_query(conn: &mut mysql_async::Conn, previous: Option) { if let Some(previous) = previous { if let Err(err) = conn.query_drop(explicit_timestamp_defaults_sql(previous)).await { log::warn!("Failed to restore MySQL explicit timestamp defaults session setting: {err}"); } } } fn mysql_connection_charset(url: &str) -> Option<&str> { let (_, query) = url.split_once('?')?; query.split('&').find_map(|segment| { let (key, value) = segment.split_once('=')?; if !key.eq_ignore_ascii_case("charset") { return None; } let value = value.trim(); is_safe_mysql_charset_name(value).then_some(value) }) } fn is_safe_mysql_charset_name(value: &str) -> bool { !value.is_empty() && value.bytes().all(|byte| byte.is_ascii_alphanumeric() || byte == b'_') } async fn verify_pool_connection(pool: &MySqlPool, timeout: Duration) -> Result<(), String> { super::with_connection_timeout("MySQL", timeout, async { let mut conn = pool.get_conn().await.map_err(|e| format!("MySQL connection failed: {e}"))?; conn.ping().await.map_err(|e| format!("MySQL ping failed: {e}"))?; Ok(()) }) .await } fn mysql_error_should_retry_without_ssl(error: &str) -> bool { let error = error.to_ascii_lowercase(); error.contains("handshakefailure") || error.contains("handshake") || error.contains("tls connection") || error.contains("server closed session") } fn mysql_error_should_retry_with_text_protocol(error: &str) -> bool { let lower = error.to_ascii_lowercase(); (lower.contains("1105") && lower.contains("hy000")) || lower.contains("prepared statement protocol") || lower.contains("this command is not supported in the prepared statement protocol yet") } fn ssl_fallback_url(url: &str) -> Option { if mysql_url_requires_ssl(url) { return None; } if url.contains("ssl-mode=preferred") { Some(url.replace("ssl-mode=preferred", "ssl-mode=disabled")) } else if !url.contains("ssl-mode=") { let sep = if url.contains('?') { "&" } else { "?" }; Some(format!("{url}{sep}ssl-mode=disabled")) } else { None } } fn mysql_url_requires_ssl(url: &str) -> bool { let Some((_, query)) = url.split_once('?') else { return false; }; query.split('&').any(|segment| { let Some((key, value)) = segment.split_once('=') else { return false; }; let key = key.trim(); let value = value.trim(); (key.eq_ignore_ascii_case("require_ssl") && value.eq_ignore_ascii_case("true")) || mysql_tls_file_param_is(key, "cert") || mysql_tls_file_param_is(key, "key") || ((key.eq_ignore_ascii_case("ssl-mode") || key.eq_ignore_ascii_case("sslmode")) && matches!( value.to_ascii_lowercase().replace('-', "_").as_str(), "required" | "require" | "verify_ca" | "verify_identity" )) }) } fn mysql_url_verifies_identity(url: &str) -> bool { let Some((_, query)) = url.split_once('?') else { return false; }; query.split('&').any(|segment| { let Some((key, value)) = segment.split_once('=') else { return false; }; let key = key.trim(); let value = value.trim(); (key.eq_ignore_ascii_case("verify_identity") && value.eq_ignore_ascii_case("true")) || ((key.eq_ignore_ascii_case("ssl-mode") || key.eq_ignore_ascii_case("sslmode")) && matches!(value.to_ascii_lowercase().replace('-', "_").as_str(), "verify_identity")) }) } fn mysql_async_url(url: &str) -> Cow<'_, str> { let Some((base, query)) = url.split_once('?') else { return Cow::Borrowed(url); }; let original_count = query.split('&').filter(|segment| !segment.trim().is_empty()).count(); let mut filtered: Vec = Vec::new(); for segment in query.split('&') { let segment = segment.trim(); if segment.is_empty() || segment.starts_with("charset=") || segment.starts_with("time_zone=") || segment.starts_with("time-zone=") || segment.to_ascii_lowercase().starts_with("connect_timeout=") || segment.to_ascii_lowercase().starts_with("connecttimeout=") { continue; } let Some((key, value)) = segment.split_once('=') else { filtered.push(segment.to_string()); continue; }; if key.eq_ignore_ascii_case("ssl-mode") || key.eq_ignore_ascii_case("sslmode") { match value.to_ascii_lowercase().replace('-', "_").as_str() { "disabled" | "disable" => filtered.push("require_ssl=false".to_string()), "required" | "require" => { filtered.push("require_ssl=true".to_string()); filtered.push("verify_ca=false".to_string()); filtered.push("verify_identity=false".to_string()); } "verify_ca" => { filtered.push("require_ssl=true".to_string()); filtered.push("verify_identity=false".to_string()); } "verify_identity" => filtered.push("require_ssl=true".to_string()), _ => {} } continue; } filtered.push(segment.to_string()); } if filtered.len() == original_count { Cow::Borrowed(url) } else if filtered.is_empty() { Cow::Owned(base.to_string()) } else { Cow::Owned(format!("{base}?{}", filtered.join("&"))) } } pub async fn connect_bare(url: &str, fallback_timeout: Duration) -> Result { let timeout = super::parse_connect_timeout_with_fallback(url, fallback_timeout); let pool = create_pool(url, None)?; verify_pool_connection(&pool, timeout).await.map(|_| pool) } pub async fn list_databases(pool: &MySqlPool) -> Result, String> { let mut conn = pool.get_conn().await.map_err(|e| e.to_string())?; let result = conn .query_iter("SELECT SCHEMA_NAME FROM information_schema.SCHEMATA ORDER BY SCHEMA_NAME") .await .map_err(|e| e.to_string())?; let rows: Vec = result.collect_and_drop().await.map_err(|e| e.to_string())?; Ok(rows.iter().map(|row| DatabaseInfo { name: get_str(row, 0) }).collect()) } pub async fn list_tables(pool: &MySqlPool, database: &str) -> Result, String> { let sql = format!( "SELECT TABLE_NAME, TABLE_TYPE, TABLE_COMMENT FROM information_schema.TABLES WHERE TABLE_SCHEMA = {} ORDER BY TABLE_NAME", quote_value(database), ); let mut conn = pool.get_conn().await.map_err(|e| e.to_string())?; let result = conn.query_iter(&sql).await.map_err(|e| e.to_string())?; let rows: Vec = result.collect_and_drop().await.map_err(|e| e.to_string())?; Ok(rows .iter() .map(|row| TableInfo { name: get_str_by_name(row, "TABLE_NAME"), table_type: get_str_by_name(row, "TABLE_TYPE"), comment: get_opt_str(row, "TABLE_COMMENT").filter(|s| !s.is_empty()), }) .collect()) } fn list_tables_objects_sql(database: &str) -> String { format!( "SELECT TABLE_NAME AS object_name, \ CASE WHEN TABLE_TYPE = 'VIEW' THEN 'VIEW' ELSE 'TABLE' END AS object_type, \ TABLE_COMMENT AS object_comment, \ CREATE_TIME AS created_at, \ UPDATE_TIME AS updated_at, \ CASE WHEN TABLE_TYPE = 'VIEW' THEN 1 ELSE 0 END AS sort_order \ FROM information_schema.TABLES \ WHERE TABLE_SCHEMA = {db} \ ORDER BY sort_order, object_name", db = quote_value(database), ) } fn list_routines_sql(database: &str) -> String { format!( "SELECT ROUTINE_NAME AS object_name, ROUTINE_TYPE AS object_type, NULL AS object_comment, \ NULL AS created_at, NULL AS updated_at, \ CASE WHEN ROUTINE_TYPE = 'PROCEDURE' THEN 2 ELSE 3 END AS sort_order \ FROM information_schema.ROUTINES \ WHERE ROUTINE_SCHEMA = {db} AND ROUTINE_TYPE IN ('PROCEDURE', 'FUNCTION') \ ORDER BY sort_order, object_name", db = quote_value(database), ) } fn row_to_object(row: &mysql_async::Row, database: &str) -> ObjectInfo { ObjectInfo { name: get_str_by_name(row, "object_name"), object_type: get_str_by_name(row, "object_type"), schema: Some(database.to_string()), comment: get_opt_str(row, "object_comment").filter(|s| !s.is_empty()), created_at: get_opt_str(row, "created_at"), updated_at: get_opt_str(row, "updated_at"), } } pub async fn list_objects(pool: &MySqlPool, database: &str) -> Result, String> { let mut conn = pool.get_conn().await.map_err(|e| e.to_string())?; let tables_sql = list_tables_objects_sql(database); let result = conn.query_iter(&tables_sql).await.map_err(|e| e.to_string())?; let table_rows: Vec = result.collect_and_drop().await.map_err(|e| e.to_string())?; let mut objects: Vec = table_rows.iter().map(|row| row_to_object(row, database)).collect(); // Routines are queried separately: some MySQL-compatible servers (sharding proxies, // OceanBase/TiDB variants, restricted accounts) reject information_schema.ROUTINES with // ER_UNKNOWN_ERROR (1105). Degrading gracefully keeps tables/views usable. let routines_sql = list_routines_sql(database); match conn.query_iter(&routines_sql).await { Ok(result) => match result.collect_and_drop::().await { Ok(routine_rows) => { objects.extend(routine_rows.iter().map(|row| row_to_object(row, database))); } Err(e) => { log::warn!("Skipping routines for database `{}` in object browser: {}", database, e); } }, Err(e) => { log::warn!("Skipping routines for database `{}` in object browser: {}", database, e); } } Ok(objects) } fn columns_sql(database: &str, table: &str) -> String { format!( "SELECT c.COLUMN_NAME, c.COLUMN_TYPE, c.IS_NULLABLE, c.COLUMN_DEFAULT, c.EXTRA, c.COLUMN_COMMENT, \ c.COLUMN_KEY, c.NUMERIC_PRECISION, c.NUMERIC_SCALE, c.CHARACTER_MAXIMUM_LENGTH \ FROM information_schema.COLUMNS c \ WHERE c.TABLE_SCHEMA = {} AND c.TABLE_NAME = {} \ ORDER BY c.ORDINAL_POSITION", quote_value(database), quote_value(table), ) } fn primary_key_columns_sql(database: &str, table: &str) -> String { format!( "SELECT COLUMN_NAME \ FROM information_schema.KEY_COLUMN_USAGE \ WHERE TABLE_SCHEMA = {} AND TABLE_NAME = {} AND CONSTRAINT_NAME = 'PRIMARY' \ ORDER BY ORDINAL_POSITION", quote_value(database), quote_value(table), ) } fn is_primary_key_column(primary_key_columns: &HashSet, name: &str, column_key: &str) -> bool { primary_key_columns.contains(name) || column_key.eq_ignore_ascii_case("PRI") } pub async fn get_columns(pool: &MySqlPool, database: &str, table: &str) -> Result, String> { let pk_sql = primary_key_columns_sql(database, table); let mut conn = pool.get_conn().await.map_err(|e| e.to_string())?; let result = conn.query_iter(&pk_sql).await.map_err(|e| e.to_string())?; let pk_rows: Vec = result.collect_and_drop().await.map_err(|e| e.to_string())?; let primary_key_columns: HashSet = pk_rows.iter().map(|row| get_str_by_name(row, "COLUMN_NAME")).collect(); drop(conn); let sql = columns_sql(database, table); let mut conn = pool.get_conn().await.map_err(|e| e.to_string())?; let result = conn.query_iter(&sql).await.map_err(|e| e.to_string())?; let rows: Vec = result.collect_and_drop().await.map_err(|e| e.to_string())?; Ok(rows .iter() .map(|row| { let name = get_str_by_name(row, "COLUMN_NAME"); let column_key = get_str_by_name(row, "COLUMN_KEY"); ColumnInfo { is_primary_key: is_primary_key_column(&primary_key_columns, &name, &column_key), name, data_type: get_str_by_name(row, "COLUMN_TYPE"), is_nullable: get_str_by_name(row, "IS_NULLABLE") == "YES", column_default: get_opt_str(row, "COLUMN_DEFAULT"), extra: get_opt_str(row, "EXTRA"), comment: get_opt_str(row, "COLUMN_COMMENT").filter(|s| !s.is_empty()), numeric_precision: get_opt_i32(row, "NUMERIC_PRECISION"), numeric_scale: get_opt_i32(row, "NUMERIC_SCALE"), character_maximum_length: get_opt_i32(row, "CHARACTER_MAXIMUM_LENGTH"), } }) .collect()) } fn query_result_row_limit(max_rows: Option) -> usize { max_rows.unwrap_or(crate::query::MAX_ROWS).max(1) } async fn execute_result_set_with_text_protocol( pool: &MySqlPool, sql: &str, row_limit: usize, start: Instant, ) -> Result { let mut conn = pool.get_conn().await.map_err(|e| e.to_string())?; let mut result = conn.query_iter(sql).await.map_err(|e| e.to_string())?; let columns: Vec = result.columns_ref().iter().map(|c| c.name_str().to_string()).collect(); let mut result_rows: Vec> = Vec::new(); let mut stream = result .stream::() .await .map_err(|e| e.to_string())? .ok_or_else(|| "Empty result set stream".to_string())?; while let Some(row) = stream.next().await { let row = row.map_err(|e| e.to_string())?; let values: Vec = (0..row.len()).map(|i| mysql_value_to_json(&row, i)).collect(); result_rows.push(values); if result_rows.len() > row_limit { break; } } let truncated = result_rows.len() > row_limit; if truncated { result_rows.truncate(row_limit); } Ok(QueryResult { columns, rows: result_rows, affected_rows: 0, execution_time_ms: start.elapsed().as_millis(), truncated, session_id: None, has_more: false, }) } async fn execute_result_set_with_prepared_protocol( pool: &MySqlPool, sql: &str, row_limit: usize, start: Instant, ) -> Result { let mut conn = pool.get_conn().await.map_err(|e| e.to_string())?; let mut result = conn.exec_iter(sql, ()).await.map_err(|e| e.to_string())?; let columns: Vec = result.columns_ref().iter().map(|c| c.name_str().to_string()).collect(); let mut result_rows: Vec> = Vec::new(); let mut stream = result .stream::() .await .map_err(|e| e.to_string())? .ok_or_else(|| "Empty result set stream".to_string())?; while let Some(row) = stream.next().await { let row = row.map_err(|e| e.to_string())?; let values: Vec = (0..row.len()).map(|i| mysql_value_to_json(&row, i)).collect(); result_rows.push(values); if result_rows.len() > row_limit { break; } } let truncated = result_rows.len() > row_limit; if truncated { result_rows.truncate(row_limit); } Ok(QueryResult { columns, rows: result_rows, affected_rows: 0, execution_time_ms: start.elapsed().as_millis(), truncated, session_id: None, has_more: false, }) } pub async fn execute_query(pool: &MySqlPool, sql: &str, bare: bool) -> Result { execute_query_with_max_rows(pool, sql, bare, None).await } pub async fn execute_query_with_max_rows( pool: &MySqlPool, sql: &str, bare: bool, max_rows: Option, ) -> Result { let start = Instant::now(); let row_limit = query_result_row_limit(max_rows); if is_result_set_query(sql) { if bare || requires_text_protocol_query(sql) { execute_result_set_with_text_protocol(pool, sql, row_limit, start).await } else { match execute_result_set_with_prepared_protocol(pool, sql, row_limit, start).await { Ok(result) => Ok(result), Err(err) if mysql_error_should_retry_with_text_protocol(&err) => { execute_result_set_with_text_protocol(pool, sql, row_limit, start).await } Err(err) => Err(err), } } } else { let mut conn = pool.get_conn().await.map_err(|e| e.to_string())?; let previous_explicit_timestamp_defaults = enable_explicit_timestamp_defaults_for_query(&mut conn, sql).await; let result = match conn.query_iter(sql).await { Ok(result) => result, Err(err) => { restore_explicit_timestamp_defaults_for_query(&mut conn, previous_explicit_timestamp_defaults).await; return Err(err.to_string()); } }; let affected_rows = result.affected_rows(); let drop_result = result.drop_result().await; restore_explicit_timestamp_defaults_for_query(&mut conn, previous_explicit_timestamp_defaults).await; drop_result.map_err(|e| e.to_string())?; Ok(QueryResult { columns: vec![], rows: vec![], affected_rows, execution_time_ms: start.elapsed().as_millis(), truncated: false, session_id: None, has_more: false, }) } } fn is_result_set_query(sql: &str) -> bool { starts_with_executable_sql_keyword(sql, &["SELECT", "SHOW", "DESCRIBE", "EXPLAIN", "WITH"]) } fn requires_text_protocol_query(sql: &str) -> bool { if !starts_with_executable_sql_keyword(sql, &["SHOW"]) { return false; } let tokens = sql.trim().trim_end_matches(';').split_whitespace().map(|token| token.to_ascii_lowercase()).collect::>(); if tokens.len() >= 2 && tokens[0] == "show" && tokens[1] == "grants" { return true; } matches!( tokens.iter().map(String::as_str).collect::>().as_slice(), ["show", "processlist"] | ["show", "full", "processlist"] | ["show", "slave", "status"] | ["show", "replica", "status"] ) } pub async fn list_indexes(pool: &MySqlPool, database: &str, table: &str) -> Result, String> { let sql = format!( "SELECT INDEX_NAME, GROUP_CONCAT(COLUMN_NAME ORDER BY SEQ_IN_INDEX) AS columns, \ MIN(NON_UNIQUE) = 0 AS is_unique, INDEX_NAME = 'PRIMARY' AS is_primary, \ INDEX_TYPE \ FROM information_schema.STATISTICS \ WHERE TABLE_SCHEMA = {} AND TABLE_NAME = {} \ GROUP BY INDEX_NAME, INDEX_TYPE \ ORDER BY INDEX_NAME", quote_value(database), quote_value(table), ); let mut conn = pool.get_conn().await.map_err(|e| e.to_string())?; let result = conn.query_iter(&sql).await.map_err(|e| e.to_string())?; let rows: Vec = result.collect_and_drop().await.map_err(|e| e.to_string())?; Ok(rows .iter() .map(|row| { let cols_str = get_str_by_name(row, "columns"); IndexInfo { name: get_str_by_name(row, "INDEX_NAME"), columns: cols_str.split(',').filter(|s| !s.is_empty()).map(|s| s.to_string()).collect(), is_unique: row.get::("is_unique").unwrap_or(false), is_primary: row.get::("is_primary").unwrap_or(false), filter: None, index_type: Some(get_str_by_name(row, "INDEX_TYPE")), included_columns: None, comment: None, } }) .collect()) } pub async fn list_foreign_keys(pool: &MySqlPool, database: &str, table: &str) -> Result, String> { let sql = format!( "SELECT kcu.CONSTRAINT_NAME, kcu.COLUMN_NAME, \ kcu.REFERENCED_TABLE_NAME, kcu.REFERENCED_COLUMN_NAME \ FROM information_schema.KEY_COLUMN_USAGE kcu \ WHERE kcu.TABLE_SCHEMA = {} AND kcu.TABLE_NAME = {} \ AND kcu.REFERENCED_TABLE_NAME IS NOT NULL \ ORDER BY kcu.CONSTRAINT_NAME", quote_value(database), quote_value(table), ); let mut conn = pool.get_conn().await.map_err(|e| e.to_string())?; let result = conn.query_iter(&sql).await.map_err(|e| e.to_string())?; let rows: Vec = result.collect_and_drop().await.map_err(|e| e.to_string())?; Ok(rows .iter() .map(|row| ForeignKeyInfo { name: get_str_by_name(row, "CONSTRAINT_NAME"), column: get_str_by_name(row, "COLUMN_NAME"), ref_table: get_str_by_name(row, "REFERENCED_TABLE_NAME"), ref_column: get_str_by_name(row, "REFERENCED_COLUMN_NAME"), }) .collect()) } pub async fn list_triggers(pool: &MySqlPool, database: &str, table: &str) -> Result, String> { let sql = format!( "SELECT TRIGGER_NAME, EVENT_MANIPULATION, ACTION_TIMING \ FROM information_schema.TRIGGERS \ WHERE TRIGGER_SCHEMA = {} AND EVENT_OBJECT_TABLE = {} \ ORDER BY TRIGGER_NAME", quote_value(database), quote_value(table), ); let mut conn = pool.get_conn().await.map_err(|e| e.to_string())?; let result = conn.query_iter(&sql).await.map_err(|e| e.to_string())?; let rows: Vec = result.collect_and_drop().await.map_err(|e| e.to_string())?; Ok(rows .iter() .map(|row| TriggerInfo { name: get_str_by_name(row, "TRIGGER_NAME"), event: get_str_by_name(row, "EVENT_MANIPULATION"), timing: get_str_by_name(row, "ACTION_TIMING"), }) .collect()) } #[cfg(test)] mod tests { use super::*; use mysql_async::consts::ColumnFlags; #[test] fn mysql_with_queries_are_treated_as_result_sets() { let sql = "WITH RECURSIVE org_tree AS (SELECT 1 AS id) SELECT id FROM org_tree"; assert!(is_result_set_query(sql)); } #[test] fn mysql_desc_queries_are_treated_as_result_sets() { assert!(is_result_set_query("DESC users")); } #[test] fn numeric_metadata_accepts_unsigned_information_schema_values() { assert_eq!(numeric_metadata_u64_to_i32(Some(65)), Some(65)); } #[test] fn numeric_metadata_ignores_values_outside_frontend_range() { assert_eq!(numeric_metadata_u64_to_i32(Some(i32::MAX as u64 + 1)), None); assert_eq!(numeric_metadata_u64_to_i32(None), None); } #[test] fn mysql_list_tables_objects_sql_includes_timestamps() { let sql = list_tables_objects_sql("app"); assert!(sql.contains("information_schema.TABLES")); assert!(!sql.contains("information_schema.ROUTINES")); assert!(!sql.contains("UNION")); assert!(sql.contains("CREATE_TIME")); assert!(sql.contains("UPDATE_TIME")); } #[test] fn mysql_list_routines_sql_is_independent_of_tables() { let sql = list_routines_sql("app"); assert!(sql.contains("information_schema.ROUTINES")); assert!(!sql.contains("information_schema.TABLES")); assert!(!sql.contains("UNION")); assert!(sql.contains("'PROCEDURE'")); assert!(sql.contains("'FUNCTION'")); assert!(!sql.contains("LAST_ALTERED")); assert!(!sql.contains("CREATED AS created_at")); } #[test] fn mysql_columns_sql_avoids_information_schema_join_collation() { let sql = columns_sql("app", "users"); assert!(!sql.contains("COLLATE")); assert!(!sql.contains("KEY_COLUMN_USAGE")); assert!(sql.contains("information_schema.COLUMNS")); } #[test] fn mysql_primary_key_columns_sql_reads_key_column_usage_separately() { let sql = primary_key_columns_sql("app", "users"); assert!(!sql.contains("COLLATE")); assert!(sql.contains("information_schema.KEY_COLUMN_USAGE")); assert!(sql.contains("CONSTRAINT_NAME = 'PRIMARY'")); } #[test] fn mysql_columns_sql_selects_column_key_for_starrocks_primary_fallback() { let sql = columns_sql("app", "users"); assert!(sql.contains("c.COLUMN_KEY")); } #[test] fn mysql_largeint_uses_lossless_integer_decoding() { assert!(is_mysql_lossless_integer_type("LARGEINT")); } fn mysql_test_column( column_type: ColumnType, character_set: u16, flags: ColumnFlags, column_length: u32, ) -> mysql_async::Column { mysql_async::Column::new(column_type) .with_character_set(character_set) .with_flags(flags) .with_column_length(column_length) } #[test] fn mysql_binary_preview_keeps_binary_collation_varchar_as_text() { let column = mysql_test_column(ColumnType::MYSQL_TYPE_VAR_STRING, 45, ColumnFlags::BINARY_FLAG, 64); assert_eq!(mysql_bytes_to_json(b"SN-A0001".to_vec(), &column), serde_json::json!("SN-A0001")); } #[test] fn mysql_binary_preview_renders_binary_and_varbinary_like_navicat_text_preview() { let binary_column = mysql_test_column(ColumnType::MYSQL_TYPE_STRING, 63, ColumnFlags::BINARY_FLAG, 8); let varbinary_column = mysql_test_column(ColumnType::MYSQL_TYPE_VAR_STRING, 63, ColumnFlags::BINARY_FLAG, 8); assert_eq!(mysql_bytes_to_json(b"150010\0\0".to_vec(), &binary_column), serde_json::json!("150010")); assert_eq!(mysql_bytes_to_json(b"150010".to_vec(), &varbinary_column), serde_json::json!("150010")); } #[test] fn mysql_binary_preview_falls_back_to_hex_for_unprintable_bytes() { let binary_column = mysql_test_column(ColumnType::MYSQL_TYPE_STRING, 63, ColumnFlags::BINARY_FLAG, 8); let varbinary_column = mysql_test_column(ColumnType::MYSQL_TYPE_VAR_STRING, 63, ColumnFlags::BINARY_FLAG, 8); assert_eq!(mysql_bytes_to_json(vec![0x01, 0x02, 0x03, 0x04], &binary_column), serde_json::json!("0x01020304")); assert_eq!( mysql_bytes_to_json(vec![0xde, 0xad, 0xbe, 0xef], &varbinary_column), serde_json::json!("0xdeadbeef") ); } #[test] fn mysql_binary_preview_uses_charset_to_separate_blob_from_text() { let text_column = mysql_test_column(ColumnType::MYSQL_TYPE_BLOB, 45, ColumnFlags::empty(), 65_535); let blob_column = mysql_test_column(ColumnType::MYSQL_TYPE_BLOB, 63, ColumnFlags::BLOB_FLAG, 65_535); assert_eq!(mysql_bytes_to_json(b"hello".to_vec(), &text_column), serde_json::json!("hello")); assert_eq!( mysql_bytes_to_json(vec![0x00, 0x01, 0xab, 0xff], &blob_column), serde_json::json!("(BLOB) 4 bytes") ); } #[test] fn mysql_bit_preview_uses_boolean_or_bit_string_text() { let bit_one = mysql_test_column(ColumnType::MYSQL_TYPE_BIT, 63, ColumnFlags::UNSIGNED_FLAG, 1); let bit_eight = mysql_test_column(ColumnType::MYSQL_TYPE_BIT, 63, ColumnFlags::UNSIGNED_FLAG, 8); assert_eq!(mysql_bit_value_to_string(&[1], &bit_one), "1"); assert_eq!(mysql_bit_value_to_string(&[0b1010_1010], &bit_eight), "10101010"); } #[test] fn mysql_column_key_marks_primary_when_key_column_usage_is_unavailable() { let primary_key_columns = HashSet::new(); assert!(is_primary_key_column(&primary_key_columns, "id", "PRI")); } #[test] fn mysql_management_show_queries_use_text_protocol() { assert!(requires_text_protocol_query("SHOW PROCESSLIST")); assert!(requires_text_protocol_query("show full processlist")); assert!(requires_text_protocol_query("SHOW SLAVE STATUS")); assert!(requires_text_protocol_query("show replica status")); assert!(requires_text_protocol_query("SHOW GRANTS")); assert!(requires_text_protocol_query("SHOW GRANTS FOR 'repl'@'%'")); assert!(!requires_text_protocol_query("SHOW TABLES")); assert!(!requires_text_protocol_query("SELECT * FROM users")); } #[test] fn mysql_timestamp_default_null_ddl_enables_explicit_defaults() { let create_sql = r#" CREATE TABLE `referral_record` ( `id` BINARY(16) NOT NULL, `created_at` TIMESTAMP(6) NOT NULL DEFAULT CURRENT_TIMESTAMP(6), `updated_at` TIMESTAMP(6) NOT NULL DEFAULT CURRENT_TIMESTAMP(6) ON UPDATE CURRENT_TIMESTAMP(6), `deleted_at` TIMESTAMP(6) DEFAULT NULL, PRIMARY KEY (`id`) ) ENGINE = InnoDB "#; assert!(should_enable_explicit_timestamp_defaults(create_sql)); assert!(should_enable_explicit_timestamp_defaults( "ALTER TABLE referral_record ADD deleted_at TIMESTAMP DEFAULT NULL" )); assert!(!should_enable_explicit_timestamp_defaults("CREATE TABLE t (deleted_at DATETIME(6) DEFAULT NULL)")); assert!(!should_enable_explicit_timestamp_defaults("SELECT 'TIMESTAMP DEFAULT NULL'")); assert_eq!(explicit_timestamp_defaults_sql(true), "SET SESSION explicit_defaults_for_timestamp = ON"); assert_eq!(explicit_timestamp_defaults_sql(false), "SET SESSION explicit_defaults_for_timestamp = OFF"); } #[test] fn mysql_tls_session_close_errors_retry_without_ssl() { let error = "MySQL connection failed: error communicating with database: \ encountered error while attempting to establish a TLS connection: \ server closed session with no notification"; assert!(mysql_error_should_retry_without_ssl(error)); } #[test] fn mysql_tls_url_strips_client_identity_params_before_driver_parse() { let dir = std::env::temp_dir(); let cert = dir.join(format!("dbx-mysql-client-cert-{}.pem", std::process::id())); let key = dir.join(format!("dbx-mysql-client-key-{}.pem", std::process::id())); std::fs::write(&cert, "not a real cert").unwrap(); std::fs::write(&key, "not a real key").unwrap(); let url = format!( "mysql://root:secret@localhost/test?require_ssl=true&ssl-cert={}&ssl-key={}&charset=utf8mb4", cert.display(), key.display() ); let parsed = mysql_tls_url(&url).unwrap(); assert_eq!(parsed.url, "mysql://root:secret@localhost/test?require_ssl=true&charset=utf8mb4"); assert_eq!(parsed.files.sslcert.as_deref(), Some(cert.to_str().unwrap())); assert_eq!(parsed.files.sslkey.as_deref(), Some(key.to_str().unwrap())); mysql_async::Opts::from_url(&mysql_async_url(&parsed.url)).unwrap(); let _ = std::fs::remove_file(cert); let _ = std::fs::remove_file(key); } #[test] fn mysql_tls_rejects_unpaired_client_cert_and_key() { let files = MySqlTlsFiles { sslcert: Some("/tmp/client.crt".to_string()), sslkey: None }; let error = mysql_ssl_opts(None, "mysql://root@localhost/db?require_ssl=true", None, &files).unwrap_err(); assert!(error.contains("ssl-key")); } #[test] fn mysql_tls_client_identity_requires_ssl() { assert!(mysql_url_requires_ssl("mysql://root@localhost/db?ssl-cert=/tmp/client.crt&ssl-key=/tmp/client.key")); } #[test] fn mysql_unknown_error_can_retry_with_text_protocol() { let error = "error returned from database: 1105 (HY000): Unknown error"; assert!(mysql_error_should_retry_with_text_protocol(error)); } #[test] fn mysql_datetime_utc_values_display_without_rfc3339_offset() { let value = NaiveDateTime::new( NaiveDate::from_ymd_opt(2026, 5, 12).unwrap(), NaiveTime::from_hms_opt(0, 0, 0).unwrap(), ); assert_eq!(mysql_datetime_to_string(value), "2026-05-12 00:00:00"); } #[tokio::test] #[ignore = "requires remote MariaDB with ed25519 user"] async fn test_ed25519_auth() { let url = "mysql://edtest:test123@172.26.128.159:20026/testdb"; let pool = super::connect(url, std::time::Duration::from_secs(5)).await.expect("connect with ed25519"); let mut conn = pool.get_conn().await.expect("get connection"); conn.ping().await.expect("ping"); let _ = conn.disconnect().await; let _ = pool.disconnect().await; } #[test] fn parse_connect_timeout_extracts_underscore_form() { let url = "mysql://host:3306/db?connect_timeout=30"; assert_eq!(crate::db::parse_connect_timeout(url), Duration::from_secs(30)); } #[test] fn parse_connect_timeout_extracts_camelcase_form() { let url = "mysql://host:3306/db?connectTimeout=60"; assert_eq!(crate::db::parse_connect_timeout(url), Duration::from_secs(60)); } #[test] fn parse_connect_timeout_ignores_out_of_range() { let default = crate::db::connection_timeout(); let url = "mysql://host:3306/db?connect_timeout=999"; assert_eq!(crate::db::parse_connect_timeout(url), default); let url2 = "mysql://host:3306/db?connect_timeout=0"; assert_eq!(crate::db::parse_connect_timeout(url2), default); } #[test] fn parse_connect_timeout_returns_default_when_missing() { let default = crate::db::connection_timeout(); let url = "mysql://host:3306/db?ssl-mode=preferred&charset=utf8mb4"; assert_eq!(crate::db::parse_connect_timeout(url), default); } #[test] fn parse_connect_timeout_returns_default_when_no_query() { let default = crate::db::connection_timeout(); let url = "mysql://host:3306/db"; assert_eq!(crate::db::parse_connect_timeout(url), default); } #[test] fn mysql_async_url_translates_standard_required_ssl_mode() { let url = "mysql://host:3306/db?ssl-mode=required&charset=utf8mb4"; assert_eq!( mysql_async_url(url).as_ref(), "mysql://host:3306/db?require_ssl=true&verify_ca=false&verify_identity=false" ); } #[test] fn ssl_fallback_does_not_disable_required_tls() { assert_eq!(ssl_fallback_url("mysql://host:3306/db?require_ssl=true&charset=utf8mb4"), None); assert_eq!(ssl_fallback_url("mysql://host:3306/db?ssl-mode=verify_ca&charset=utf8mb4"), None); } #[test] fn mysql_setup_queries_default_to_utf8mb4() { assert_eq!(mysql_setup_queries("mysql://host:3306/db"), vec!["SET NAMES utf8mb4"]); } #[test] fn mysql_setup_queries_use_safe_custom_charset() { assert_eq!(mysql_setup_queries("mysql://host:3306/db?ssl-mode=preferred&charset=gbk"), vec!["SET NAMES gbk"]); assert_eq!( mysql_setup_queries("mysql://host:3306/db?charset=utf8mb4;DROP TABLE users"), vec!["SET NAMES utf8mb4"] ); } }