Skip to content

armgit / dbx

Public Imported from GitHub
0

25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。

6.7 KB
Raw Blame
use super::{
    write_bytes, DataGridExtractColumn, DataGridExtractError, DataGridExtractErrorCode, DataGridExtractWarning,
    DataGridExtractWarningCode, ExtractContext,
};
use serde::ser::{SerializeMap, SerializeSeq};
use serde::{Serialize, Serializer};
use std::io::Write;

pub(super) fn write_json(
    context: &ExtractContext<'_>,
    output: &mut dyn Write,
) -> Result<Vec<DataGridExtractWarning>, DataGridExtractError> {
    // Values-only output is only well-defined for a single-column selection;
    // anything else keeps the object form so no column is silently dropped.
    if context.request.options.json.values_only && context.selected_source_indexes.len() == 1 {
        return write_json_values(context, output);
    }
    let (names, warnings) =
        unique_json_names(&context.selected_columns, context.request.options.json.camel_case_field_names);
    let rows =
        JsonRows { names: &names, source_indexes: &context.selected_source_indexes, rows: &context.request.rows };
    let result = if context.request.options.json.pretty {
        serde_json::to_writer_pretty(output, &rows)
    } else {
        serde_json::to_writer(output, &rows)
    };
    result.map_err(|error| {
        DataGridExtractError::new(
            DataGridExtractErrorCode::EncodingFailed,
            format!("Failed to encode JSON extractor output: {error}"),
        )
    })?;
    Ok(warnings)
}

fn write_json_values(
    context: &ExtractContext<'_>,
    output: &mut dyn Write,
) -> Result<Vec<DataGridExtractWarning>, DataGridExtractError> {
    let values = JsonValues { source_index: context.selected_source_indexes[0], rows: &context.request.rows };
    let result = if context.request.options.json.pretty {
        serde_json::to_writer_pretty(output, &values)
    } else {
        serde_json::to_writer(output, &values)
    };
    result.map_err(|error| {
        DataGridExtractError::new(
            DataGridExtractErrorCode::EncodingFailed,
            format!("Failed to encode JSON extractor output: {error}"),
        )
    })?;
    Ok(Vec::new())
}

pub(super) fn write_json_lines(
    context: &ExtractContext<'_>,
    output: &mut dyn Write,
) -> Result<Vec<DataGridExtractWarning>, DataGridExtractError> {
    let (names, warnings) =
        unique_json_names(&context.selected_columns, context.request.options.json.camel_case_field_names);
    for (index, row) in context.request.rows.iter().enumerate() {
        if index > 0 {
            write_bytes(output, b"\n")?;
        }
        serde_json::to_writer(
            &mut *output,
            &JsonRow { names: &names, source_indexes: &context.selected_source_indexes, values: row },
        )
        .map_err(|error| {
            DataGridExtractError::new(
                DataGridExtractErrorCode::EncodingFailed,
                format!("Failed to encode JSON Lines extractor output: {error}"),
            )
        })?;
    }
    Ok(warnings)
}

struct JsonRows<'a, 'value> {
    names: &'a [String],
    source_indexes: &'a [usize],
    rows: &'value [Vec<serde_json::Value>],
}

impl Serialize for JsonRows<'_, '_> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut sequence = serializer.serialize_seq(Some(self.rows.len()))?;
        for row in self.rows {
            sequence.serialize_element(&JsonRow {
                names: self.names,
                source_indexes: self.source_indexes,
                values: row,
            })?;
        }
        sequence.end()
    }
}

struct JsonValues<'value> {
    source_index: usize,
    rows: &'value [Vec<serde_json::Value>],
}

impl Serialize for JsonValues<'_> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut sequence = serializer.serialize_seq(Some(self.rows.len()))?;
        for row in self.rows {
            sequence.serialize_element(&row[self.source_index])?;
        }
        sequence.end()
    }
}

struct JsonRow<'a, 'value> {
    names: &'a [String],
    source_indexes: &'a [usize],
    values: &'value [serde_json::Value],
}

impl Serialize for JsonRow<'_, '_> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut map = serializer.serialize_map(Some(self.names.len()))?;
        for (name, source_index) in self.names.iter().zip(self.source_indexes) {
            map.serialize_entry(name, &self.values[*source_index])?;
        }
        map.end()
    }
}

fn unique_json_names(
    columns: &[&DataGridExtractColumn],
    camel_case_field_names: bool,
) -> (Vec<String>, Vec<DataGridExtractWarning>) {
    let base_names = columns
        .iter()
        .map(|column| {
            if camel_case_field_names {
                lower_camel_json_name(&column.display_name)
            } else {
                column.display_name.clone()
            }
        })
        .collect::<Vec<_>>();
    let reserved = base_names.iter().map(String::as_str).collect::<std::collections::HashSet<_>>();
    let mut emitted = std::collections::HashSet::<String>::new();
    let mut suffixes = std::collections::HashMap::<String, usize>::new();
    let mut duplicate = false;
    let names = base_names
        .iter()
        .map(|base| {
            let base = base.clone();
            if emitted.insert(base.clone()) {
                return base;
            }
            duplicate = true;
            let suffix = suffixes.entry(base.clone()).or_insert(2);
            loop {
                let candidate = format!("{base}_{suffix}");
                *suffix += 1;
                if !reserved.contains(candidate.as_str()) && emitted.insert(candidate.clone()) {
                    return candidate;
                }
            }
        })
        .collect();
    let warnings = if duplicate {
        vec![DataGridExtractWarning {
            code: DataGridExtractWarningCode::DuplicateJsonColumnNames,
            message: "Duplicate JSON column names were suffixed to prevent data loss.".to_string(),
        }]
    } else {
        Vec::new()
    };
    (names, warnings)
}

fn lower_camel_json_name(name: &str) -> String {
    if !name.contains('_') {
        return if name.chars().any(char::is_lowercase) { name.to_owned() } else { name.to_lowercase() };
    }

    let mut words = name.split('_').filter(|word| !word.is_empty());
    let Some(first) = words.next() else {
        return name.to_owned();
    };
    let mut converted = first.to_lowercase();
    for word in words {
        let mut characters = word.chars();
        if let Some(first_character) = characters.next() {
            converted.extend(first_character.to_uppercase());
            converted.extend(characters.flat_map(char::to_lowercase));
        }
    }
    converted
}