Use serde_json::Value is an intermediate state, and the performance of sea-orm will be lost

[baoyachi]

Is it possible to receive sqlx's Row object directly through the object for conversion without intervening serde_json::Value. At present, serde_json::Value is an intermediate state, and the performance of sea-orm will be lost.

The code like this:

[billy1624]

Hey @baoyachi, thanks for the digging!

Internally, in SeaORM, we offer an into_json() method to map sqlx::Row directly to serde_json::Value

let cake: Option<serde_json::Value> = Cake::find_by_id(1)
    .into_json()
    .one(db)
    .await?;

assert_eq!(
    cake,
    Some(serde_json::json!({
        "id": 1,
        "name": "Cheese Cake"
    }))
);

https://www.sea-ql.org/SeaORM/docs/basic-crud/json/

The source code responsible for the conversion from sqlx::Row to serde_json::Value: https://github.com/SeaQL/sea-orm/blob/master/src/query/json.rs

[billy1624]

I'm not sure if I answer your question. Is this a question that asking such conversion is possible or not? Or, this is a request for optimization of existing code? If so, could you point out the source code that needs to be refactor?

[main--]

I'm pretty sure I understand what @baoyachi means here (I found this issue through google).

sea-orm/src/executor/query.rs

Lines 643 to 687 in 4584099

	pub trait TryGetableFromJson: Sized
	where
	for<'de> Self: serde::Deserialize<'de>,
	{
	/// Ensure the type implements this method
	#[allow(unused_variables, unreachable_code)]
	fn try_get_from_json(res: &QueryResult, pre: &str, col: &str) -> Result<Self, TryGetError> {
	let column = format!("{}{}", pre, col);
	let res: Result<_, _> = match &res.row {
	#[cfg(feature = "sqlx-mysql")]
	QueryResultRow::SqlxMySql(row) => {
	use sqlx::Row;
	row.try_get::<Option<serde_json::Value>, _>(column.as_str())
	.map_err(|e| TryGetError::DbErr(crate::sqlx_error_to_query_err(e)))
	.and_then(|opt| opt.ok_or(TryGetError::Null(column)))
	}
	#[cfg(feature = "sqlx-postgres")]
	QueryResultRow::SqlxPostgres(row) => {
	use sqlx::Row;
	row.try_get::<Option<serde_json::Value>, _>(column.as_str())
	.map_err(|e| TryGetError::DbErr(crate::sqlx_error_to_query_err(e)))
	.and_then(|opt| opt.ok_or(TryGetError::Null(column)))
	}
	#[cfg(feature = "sqlx-sqlite")]
	QueryResultRow::SqlxSqlite(row) => {
	use sqlx::Row;
	row.try_get::<Option<serde_json::Value>, _>(column.as_str())
	.map_err(|e| TryGetError::DbErr(crate::sqlx_error_to_query_err(e)))
	.and_then(|opt| opt.ok_or(TryGetError::Null(column)))
	}
	#[cfg(feature = "mock")]
	QueryResultRow::Mock(row) => {
	row.try_get::<serde_json::Value>(column.as_str())
	.map_err(|e| {
	debug_print!("{:#?}", e.to_string());
	TryGetError::Null(column)
	})
	}
	#[allow(unreachable_patterns)]
	_ => unreachable!(),
	};
	res.and_then(|json| {
	serde_json::from_value(json).map_err(|e| TryGetError::DbErr(DbErr::Json(e.to_string())))
	})
	}

The implementation of TryGetableFromJson always gets the value as Option<serde_json::Value> first, and then invokes serde_json::from_value. This is not optimal. Instead, it would be better to directly get Option<sqlx::types::Json<Self>> from the database and just unpack it. The temporary serde_json::Value is unnecessary.

For example, if I deserialize struct Foo { a: i32, b: i32 }, then serde-json could directly produce this as a plain 8-bytes value. However, deserializing it as serde_json::Value first causes String allocations for "a" and "b" as well as a BTreeMap or IndexMap to store the object. This is clearly not ideal for performance.

[baoyachi]

@main-- you are right

[billy1624]

Hey @baoyachi, thanks for the clarification! Now I see what @baoyachi want to say. Please check #1249

[baoyachi]

Hey @baoyachi, thanks for the clarification! Now I see what @baoyachi want to say. Please check #1249

@billy1624 How much performance will be improved? Is there a numerical result comparison？