Rust+SQLX处理Postgres未知类型查询遇阻求解决方案

问题根源 #

你遇到的乱码和Utf8Error，本质是所有列都强行按UTF-8字符串解析导致的。非字符串类型（比如INT8整数）的原始字节并非UTF-8编码，直接转字符串必然出现乱码或解码错误。

解决方案 #

核心思路是根据列的实际类型选择对应的解析逻辑，结合SQLX的类型信息或information_schema的类型字符串，将数据库类型映射为Rust类型后再转成字符串。

方案1：利用SQLX内置的TypeInfo解析 #

SQLX的Column对象提供type_info()方法，可以直接获取列的数据库类型信息，据此匹配解析逻辑：

use sqlx::{Row, TypeInfo};
// 根据你的数据库引入对应TypeInfo，比如PostgreSQL用PgTypeInfo，MySQL用MySqlTypeInfo
use sqlx::postgres::PgTypeInfo;

// 假设rows是查询返回的结果集
for r in rows {
    let mut row_result: Vec<String> = Vec::new();
    for col in r.columns() {
        let type_name = col.type_info().name();
        let value_str = match type_name {
            // 整数类型
            "INT8" | "BIGINT" => r.try_get::<i64, _>(col.ordinal())
                .map(|v| v.to_string())
                .unwrap_or_else(|_| "ERROR".to_string()),
            // 字符串类型
            "VARCHAR" | "TEXT" | "CHAR" => r.try_get::<&str, _>(col.ordinal())
                .map(|v| v.to_string())
                .unwrap_or_else(|_| "ERROR".to_string()),
            // 布尔类型
            "BOOL" | "BOOLEAN" => r.try_get::<bool, _>(col.ordinal())
                .map(|v| v.to_string())
                .unwrap_or_else(|_| "ERROR".to_string()),
            // 浮点数类型
            "FLOAT8" | "DOUBLE PRECISION" => r.try_get::<f64, _>(col.ordinal())
                .map(|v| v.to_string())
                .unwrap_or_else(|_| "ERROR".to_string()),
            // 日期时间类型（需启用sqlx的chrono feature）
            "DATE" => r.try_get::<chrono::NaiveDate, _>(col.ordinal())
                .map(|v| v.to_string())
                .unwrap_or_else(|_| "ERROR".to_string()),
            "TIMESTAMP" => r.try_get::<chrono::NaiveDateTime, _>(col.ordinal())
                .map(|v| v.to_string())
                .unwrap_or_else(|_| "ERROR".to_string()),
            // 未知/二进制类型：转十六进制避免乱码
            _ => {
                let raw = r.try_get_raw(col.ordinal()).unwrap();
                if raw.is_null() {
                    "NULL".to_string()
                } else {
                    hex::encode(raw).to_string()
                }
            }
        };
        row_result.push(value_str);
    }
    result.push(row_result);
}

方案2：结合information_schema的类型字符串 #

如果你已经从information_schema.columns获取了data_type字段，可以直接用这个标准类型字符串做匹配（兼容性更好）：

use sqlx::Row;
use hex;
use chrono;

// 假设你已提前查询到每个列的data_type，存在col_types列表中
for (idx, col) in r.columns().enumerate() {
    let data_type = &col_types[idx];
    let value_str = match data_type.as_str() {
        "bigint" => r.try_get::<i64, _>(idx)
            .map(|v| v.to_string())
            .unwrap_or_else(|_| "ERROR".to_string()),
        "varchar" | "text" | "char" => r.try_get::<&str, _>(idx)
            .map(|v| v.to_string())
            .unwrap_or_else(|_| "ERROR".to_string()),
        "boolean" => r.try_get::<bool, _>(idx)
            .map(|v| v.to_string())
            .unwrap_or_else(|_| "ERROR".to_string()),
        "double precision" | "float" => r.try_get::<f64, _>(idx)
            .map(|v| v.to_string())
            .unwrap_or_else(|_| "ERROR".to_string()),
        "date" => r.try_get::<chrono::NaiveDate, _>(idx)
            .map(|v| v.to_string())
            .unwrap_or_else(|_| "ERROR".to_string()),
        "timestamp without time zone" => r.try_get::<chrono::NaiveDateTime, _>(idx)
            .map(|v| v.to_string())
            .unwrap_or_else(|_| "ERROR".to_string()),
        // 补充你需要支持的其他类型
        _ => {
            let raw = r.try_get_raw(idx).unwrap();
            raw.is_null().then_some("NULL".to_string()).unwrap_or_else(|| hex::encode(raw).to_string())
        }
    };
    row_result.push(value_str);
}

注意事项 #

• 不同数据库的类型名称存在差异：比如PostgreSQL的整数类型是INT8，MySQL是bigint，需要根据你使用的数据库调整匹配字符串。
• 处理日期时间类型时，需要在Cargo.toml中启用SQLX的chrono feature，同时添加依赖：

  [dependencies]
  sqlx = { version = "0.7", features = ["postgres", "chrono", "runtime-tokio-native-tls"] }
  chrono = "0.4"
  hex = "0.4"
  

• 对于解析错误（比如类型不匹配），可以根据需求替换unwrap_or_else的逻辑，比如返回具体错误信息而非统一的ERROR。

内容的提问来源于stack exchange，提问作者Ayan Banerjee