use super::{run_on, ExecError, RowRef, SqlExecutor};
use crate::core::SelectQuery;
use crate::sql::Pool;
use crate::hex::hex_encode;
#[cfg(any(feature = "postgres", feature = "mysql", feature = "sqlite"))]
pub(super) fn cell_is_null<R: sqlx::Row, I: sqlx::ColumnIndex<R>>(row: &R, index: I) -> bool {
use sqlx::ValueRef as _;
match row.try_get_raw(index) {
Ok(v) => v.is_null(),
Err(_) => true,
}
}
pub(crate) type JsonCell = fn(serde_json::Value) -> serde_json::Value;
fn json_as_is(v: serde_json::Value) -> serde_json::Value {
v
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum OnBadCell {
Null,
Fail,
}
impl OnBadCell {
fn settle(
self,
cell: Result<serde_json::Value, sqlx::Error>,
) -> Result<serde_json::Value, sqlx::Error> {
match (cell, self) {
(Err(_), Self::Null) => Ok(serde_json::Value::Null),
(cell, _) => cell,
}
}
}
#[derive(Debug, Clone, Copy)]
pub(crate) struct CellDecode {
pub(crate) json: JsonCell,
pub(crate) on_bad: OnBadCell,
}
impl CellDecode {
const LENIENT: Self = Self {
json: json_as_is,
on_bad: OnBadCell::Null,
};
}
fn lenient(row: Result<serde_json::Value, sqlx::Error>) -> serde_json::Value {
row.unwrap_or_else(|e| unreachable!("a lenient row decode failed: {e}"))
}
fn finite(field: &crate::core::FieldSchema, n: f64) -> Result<serde_json::Value, sqlx::Error> {
serde_json::Number::from_f64(n)
.map(serde_json::Value::Number)
.ok_or_else(|| bad_cell(field, format!("{n} has no JSON form")))
}
fn bad_cell(field: &crate::core::FieldSchema, why: String) -> sqlx::Error {
sqlx::Error::ColumnDecode {
index: format!("{:?}", field.column),
source: why.into(),
}
}
#[cfg(any(feature = "postgres", feature = "mysql"))]
fn row_to_json_generic<'r, R>(
row: &'r R,
fields: &[&'static crate::core::FieldSchema],
uuid_cell: fn(&'r R, &str) -> Result<uuid::Uuid, sqlx::Error>,
pg_only: fn(&'r R, &crate::core::FieldSchema) -> Result<serde_json::Value, sqlx::Error>,
decode: CellDecode,
) -> Result<serde_json::Value, sqlx::Error>
where
R: sqlx::Row,
&'r str: sqlx::ColumnIndex<R>,
i16: sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
i32: sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
i64: sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
f32: sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
f64: sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
bool: sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
String: sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
chrono::NaiveDate: sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
chrono::NaiveTime: sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
chrono::DateTime<chrono::Utc>: sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
serde_json::Value: sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
rust_decimal::Decimal: sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
Vec<u8>: sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
{
use crate::core::FieldType;
use serde_json::{json, Value};
let mut map = serde_json::Map::new();
for field in fields {
if cell_is_null(row, field.column) {
map.insert(field.name.to_owned(), Value::Null);
continue;
}
let value = match field.ty {
FieldType::I16 => row.try_get::<i16, _>(field.column).map(|n| json!(n)),
FieldType::I32 => row.try_get::<i32, _>(field.column).map(|n| json!(n)),
FieldType::I64 => row.try_get::<i64, _>(field.column).map(|n| json!(n)),
FieldType::F32 => row
.try_get::<f32, _>(field.column)
.and_then(|n| finite(field, f64::from(n)).map(|_| crate::core::__json_value(&n))),
FieldType::F64 => row
.try_get::<f64, _>(field.column)
.and_then(|n| finite(field, n)),
FieldType::Bool => row.try_get::<bool, _>(field.column).map(|b| json!(b)),
FieldType::String => row.try_get::<String, _>(field.column).map(|s| json!(s)),
FieldType::Date => row
.try_get::<chrono::NaiveDate, _>(field.column)
.map(|d| json!(d.to_string())),
FieldType::DateTime => row
.try_get::<chrono::DateTime<chrono::Utc>, _>(field.column)
.map(|dt| json!(dt.to_rfc3339())),
FieldType::Uuid => uuid_cell(row, field.column).map(|u| json!(u.to_string())),
FieldType::Json => row
.try_get::<serde_json::Value, _>(field.column)
.map(decode.json),
FieldType::Decimal => row
.try_get::<rust_decimal::Decimal, _>(field.column)
.map(|d| json!(d.to_string())),
FieldType::Binary => row
.try_get::<Vec<u8>, _>(field.column)
.map(|b| json!(hex_encode(&b))),
FieldType::Time => row
.try_get::<chrono::NaiveTime, _>(field.column)
.map(|t| json!(t.to_string())),
FieldType::Array(_)
| FieldType::Range(_)
| FieldType::HStore
| FieldType::Vector(_)
| FieldType::Geometry(_) => pg_only(row, field),
};
map.insert(field.name.to_owned(), decode.on_bad.settle(value)?);
}
Ok(Value::Object(map))
}
#[must_use]
#[cfg(feature = "postgres")]
pub fn row_to_json(
row: &sqlx::postgres::PgRow,
fields: &[&'static crate::core::FieldSchema],
) -> serde_json::Value {
lenient(row_to_json_pg_with(row, fields, CellDecode::LENIENT))
}
#[cfg(feature = "postgres")]
fn row_to_json_pg_with(
row: &sqlx::postgres::PgRow,
fields: &[&'static crate::core::FieldSchema],
decode: CellDecode,
) -> Result<serde_json::Value, sqlx::Error> {
row_to_json_generic(
row,
fields,
|row, col| sqlx::Row::try_get::<uuid::Uuid, _>(row, col),
pg_only_cell,
decode,
)
}
#[cfg(feature = "postgres")]
fn pg_only_cell(
row: &sqlx::postgres::PgRow,
field: &crate::core::FieldSchema,
) -> Result<serde_json::Value, sqlx::Error> {
use crate::core::{ArrayElem, FieldType, RangeElem, SqlValue};
use serde_json::Value;
use sqlx::Row as _;
let json = |r: Result<Value, serde_json::Error>| r.map_err(|e| bad_cell(field, e.to_string()));
let literal = |v: SqlValue| match v {
SqlValue::RangeLiteral(s) => Ok(Value::String(s)),
other => Err(bad_cell(field, format!("not a range literal: {other:?}"))),
};
let col = field.column;
match field.ty {
FieldType::Array(ArrayElem::Text) => json(serde_json::to_value(
row.try_get::<Vec<Option<String>>, _>(col)?,
)),
FieldType::Array(ArrayElem::Int) => json(serde_json::to_value(
row.try_get::<Vec<Option<i32>>, _>(col)?,
)),
FieldType::Array(ArrayElem::BigInt) => json(serde_json::to_value(
row.try_get::<Vec<Option<i64>>, _>(col)?,
)),
FieldType::Range(RangeElem::Int) => {
literal(row.try_get::<crate::sql::Range<i32>, _>(col)?.into())
}
FieldType::Range(RangeElem::BigInt) => {
literal(row.try_get::<crate::sql::Range<i64>, _>(col)?.into())
}
FieldType::Range(RangeElem::Numeric) => literal(
row.try_get::<crate::sql::Range<rust_decimal::Decimal>, _>(col)?
.into(),
),
FieldType::Range(RangeElem::Date) => literal(
row.try_get::<crate::sql::Range<chrono::NaiveDate>, _>(col)?
.into(),
),
FieldType::Range(RangeElem::DateTime) => literal(
row.try_get::<crate::sql::Range<chrono::DateTime<chrono::Utc>>, _>(col)?
.into(),
),
FieldType::HStore => json(serde_json::to_value(
row.try_get::<crate::sql::HStore, _>(col)?,
)),
FieldType::Vector(_) => json(serde_json::to_value(
row.try_get::<crate::sql::Vector, _>(col)?,
)),
FieldType::Geometry(_) => json(serde_json::to_value(
row.try_get::<crate::sql::Point, _>(col)?,
)),
_ => Ok(Value::Null),
}
}
#[cfg(feature = "mysql")]
#[must_use]
pub fn row_to_json_my(
row: &sqlx::mysql::MySqlRow,
fields: &[&'static crate::core::FieldSchema],
) -> serde_json::Value {
lenient(row_to_json_my_with(row, fields, CellDecode::LENIENT))
}
#[cfg(feature = "mysql")]
fn row_to_json_my_with(
row: &sqlx::mysql::MySqlRow,
fields: &[&'static crate::core::FieldSchema],
decode: CellDecode,
) -> Result<serde_json::Value, sqlx::Error> {
row_to_json_generic(
row,
fields,
crate::sql::try_get_flat_my::<uuid::Uuid>,
|_, _| Ok(serde_json::Value::Null),
decode,
)
}
#[cfg(feature = "sqlite")]
#[must_use]
pub fn row_to_json_sqlite(
row: &sqlx::sqlite::SqliteRow,
fields: &[&'static crate::core::FieldSchema],
) -> serde_json::Value {
lenient(row_to_json_sqlite_with(row, fields, CellDecode::LENIENT))
}
#[cfg(feature = "sqlite")]
fn row_to_json_sqlite_with(
row: &sqlx::sqlite::SqliteRow,
fields: &[&'static crate::core::FieldSchema],
decode: CellDecode,
) -> Result<serde_json::Value, sqlx::Error> {
use crate::core::FieldType;
use serde_json::{json, Value};
use sqlx::Row as _;
let or_text = |cell: Result<Value, sqlx::Error>, col: &str| {
cell.or_else(|_| row.try_get::<String, _>(col).map(|s| json!(s)))
};
let mut map = serde_json::Map::new();
for field in fields {
if cell_is_null(row, field.column) {
map.insert(field.name.to_owned(), Value::Null);
continue;
}
let col = field.column;
let value = match field.ty {
FieldType::I16 => row.try_get::<i16, _>(col).map(|n| json!(n)),
FieldType::I32 => row.try_get::<i32, _>(col).map(|n| json!(n)),
FieldType::I64 => row.try_get::<i64, _>(col).map(|n| json!(n)),
FieldType::F32 => row
.try_get::<f32, _>(col)
.and_then(|n| finite(field, f64::from(n)).map(|_| crate::core::__json_value(&n))),
FieldType::F64 => row.try_get::<f64, _>(col).and_then(|n| finite(field, n)),
FieldType::Bool => row.try_get::<bool, _>(col).map(|b| json!(b)),
FieldType::String => row.try_get::<String, _>(col).map(|s| json!(s)),
FieldType::Date => or_text(
row.try_get::<chrono::NaiveDate, _>(col)
.map(|d| json!(d.to_string())),
col,
),
FieldType::DateTime => or_text(
row.try_get::<chrono::DateTime<chrono::Utc>, _>(col)
.map(|dt| json!(dt.to_rfc3339())),
col,
),
FieldType::Uuid => or_text(
row.try_get::<uuid::Uuid, _>(col)
.map(|u| json!(u.to_string())),
col,
),
FieldType::Json => row.try_get::<String, _>(col).and_then(|s| {
match (serde_json::from_str(&s), decode.on_bad) {
(Ok(v), _) => Ok((decode.json)(v)),
(Err(_), OnBadCell::Null) => Ok(Value::String(s)),
(Err(e), OnBadCell::Fail) => Err(bad_cell(field, format!("not JSON: {e}"))),
}
}),
FieldType::Decimal => row
.try_get::<String, _>(col)
.map(|s| json!(s))
.or_else(|_| row.try_get::<i64, _>(col).map(|n| json!(n.to_string())))
.or_else(|_| row.try_get::<f64, _>(col).map(|n| json!(n.to_string()))),
FieldType::Binary => row
.try_get::<Vec<u8>, _>(col)
.map(|b| json!(hex_encode(&b))),
FieldType::Time => or_text(
row.try_get::<chrono::NaiveTime, _>(col)
.map(|t| json!(t.to_string())),
col,
),
FieldType::Array(_)
| FieldType::Range(_)
| FieldType::HStore
| FieldType::Vector(_)
| FieldType::Geometry(_) => Ok(Value::Null),
};
map.insert(field.name.to_owned(), decode.on_bad.settle(value)?);
}
Ok(Value::Object(map))
}
pub async fn select_rows_as_json(
pool: &Pool,
query: &SelectQuery,
fields: &[&'static crate::core::FieldSchema],
) -> Result<Vec<serde_json::Value>, ExecError> {
select_rows_as_json_with(pool, query, fields, CellDecode::LENIENT).await
}
pub(crate) async fn select_rows_as_json_with(
pool: &Pool,
query: &SelectQuery,
fields: &[&'static crate::core::FieldSchema],
decode: CellDecode,
) -> Result<Vec<serde_json::Value>, ExecError> {
rows_as_json_on(pool, query, fields, decode).await
}
async fn rows_as_json_on<'c, E: SqlExecutor<'c>>(
exec: E,
query: &SelectQuery,
fields: &[&'static crate::core::FieldSchema],
decode: CellDecode,
) -> Result<Vec<serde_json::Value>, ExecError> {
let stmt = exec.dialect().compile_select(query)?;
let joined = joined_columns(&query.joins);
let joined = &joined;
run_on(exec, &stmt.sql, stmt.params, move |row| {
#[allow(unused_mut)]
let mut json;
match row {
#[cfg(feature = "postgres")]
RowRef::Postgres(r) => {
json = row_to_json_pg_with(r, fields, decode)?;
augment_joined_columns(&mut json, r, joined);
}
#[cfg(feature = "mysql")]
RowRef::Mysql(r) => {
json = row_to_json_my_with(r, fields, decode)?;
augment_joined_columns(&mut json, r, joined);
}
#[cfg(feature = "sqlite")]
RowRef::Sqlite(r) => {
json = row_to_json_sqlite_with(r, fields, decode)?;
augment_joined_columns(&mut json, r, joined);
}
}
Ok(json)
})
.await
}
fn joined_columns(joins: &[crate::core::Join]) -> Vec<(String, crate::core::joins::JoinedLabel)> {
joins
.iter()
.flat_map(|join| {
join.project.iter().map(|col| {
(
crate::core::joins::joined_key(join.alias, col),
crate::core::joins::joined_label(join.alias, col),
)
})
})
.collect()
}
fn augment_joined_columns<R>(
out: &mut serde_json::Value,
row: &R,
joined: &[(String, crate::core::joins::JoinedLabel)],
) where
R: sqlx::Row,
for<'a> &'a str: sqlx::ColumnIndex<R>,
Option<String>: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
{
let Some(map) = out.as_object_mut() else {
return;
};
for (key, label) in joined {
let v = row
.try_get::<Option<String>, _>(label.as_str())
.ok()
.flatten();
map.insert(
key.clone(),
v.map(serde_json::Value::String)
.unwrap_or(serde_json::Value::Null),
);
}
}
pub async fn select_one_row_as_json(
pool: &Pool,
query: &SelectQuery,
fields: &[&'static crate::core::FieldSchema],
) -> Result<Option<serde_json::Value>, ExecError> {
Ok(select_rows_as_json(pool, query, fields)
.await?
.into_iter()
.next())
}
#[cfg(feature = "admin")]
pub(crate) async fn select_rows_as_json_tx(
tx: &mut crate::sql::PoolTx<'_>,
query: &SelectQuery,
fields: &[&'static crate::core::FieldSchema],
) -> Result<Vec<serde_json::Value>, ExecError> {
rows_as_json_on(tx, query, fields, CellDecode::LENIENT).await
}
#[cfg(feature = "admin")]
pub(crate) async fn select_one_row_as_json_tx(
tx: &mut crate::sql::PoolTx<'_>,
query: &SelectQuery,
fields: &[&'static crate::core::FieldSchema],
) -> Result<Option<serde_json::Value>, ExecError> {
Ok(select_rows_as_json_tx(tx, query, fields)
.await?
.into_iter()
.next())
}