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。
TypeScript aicliclickhousedatabasedatabase-clientdatabase-managementdockerguimcpmongodbmysqlpostgresqlredisrustsql-serversqlitetaurivue
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
}