1use std::{fmt::Write as _, sync::Arc};
4
5use async_trait::async_trait;
6use bytes::BufMut as _;
7use fraiseql_error::{FraiseQLError, Result};
8use tokio_postgres::{
9 Row,
10 types::{FromSql, Kind, Type},
11};
12
13use super::{
14 PostgresAdapter, build_projection_select_sql, build_where_select_sql,
15 build_where_select_sql_ordered, composed::build_composed_select_sql, jsonb_cell,
16 numeric::PgNumericText,
17};
18use crate::{
19 identifier::quote_postgres_identifier,
20 postgres::pg_detail,
21 traits::{
22 ColumnRowStream, ComposedLevel, DatabaseAdapter, JsonbRowStream, ProjectionRequest, Writer,
23 },
24 types::{
25 DatabaseType, JsonbValue, PoolMetrics, ReadRouting,
26 sql_hints::{OrderByClause, SqlProjectionHint},
27 },
28 where_clause::WhereClause,
29};
30
31type RowMap = std::collections::HashMap<String, serde_json::Value>;
33
34struct PreparedCall<'r> {
37 function_name: &'r str,
38 sql: String,
39 args: Vec<FlexParam>,
40 configuration: Vec<(&'r str, &'r str)>,
41 mechanism: &'static str,
45 derived: Option<&'r crate::traits::DerivedCascade<'r>>,
46 report_changes: Option<i32>,
49}
50
51impl<'r> PreparedCall<'r> {
52 fn new(adapter: &'r PostgresAdapter, request: &crate::traits::WriteRequest<'r>) -> Self {
53 let crate::traits::WriteRequest {
54 function: function_name,
55 args,
56 session_vars,
57 changelog,
58 derived_cascade,
59 report_changes,
60 ..
61 } = *request;
62 let quoted_fn = quote_postgres_identifier(function_name);
63
64 let sql = if let Some(cl) = changelog {
68 build_changelog_cte_sql("ed_fn, args.len(), cl.pre_image)
69 } else {
70 let placeholders: Vec<String> = (1..=args.len()).map(|i| format!("${i}")).collect();
71 format!("SELECT * FROM {quoted_fn}({})", placeholders.join(", "))
72 };
73
74 let mut flex_args: Vec<FlexParam> = args
79 .iter()
80 .map(|v| match v {
81 serde_json::Value::Null => FlexParam::Null,
82 value => FlexParam::Value(value.clone()),
83 })
84 .collect();
85 if let Some(changelog) = changelog {
86 flex_args.push(FlexParam::Text(changelog.object_type.to_string()));
96 flex_args.push(FlexParam::Text(changelog.modification_type.to_string()));
97 flex_args.push(
100 changelog.tenant_id.map_or(FlexParam::Null, |t| FlexParam::Text(t.to_string())),
101 );
102 flex_args.push(
104 changelog.trace_id.map_or(FlexParam::Null, |t| FlexParam::Text(t.to_string())),
105 );
106 flex_args.push(
108 changelog
109 .schema_version
110 .map_or(FlexParam::Null, |s| FlexParam::Text(s.to_string())),
111 );
112 flex_args.push(
114 changelog
115 .trace_context
116 .map_or(FlexParam::Null, |s| FlexParam::Text(s.to_string())),
117 );
118 flex_args.push(
120 changelog.actor_type.map_or(FlexParam::Null, |s| FlexParam::Text(s.to_string())),
121 );
122 flex_args.push(
125 changelog.acting_for.map_or(FlexParam::Null, |u| FlexParam::Text(u.to_string())),
126 );
127 flex_args.push(
130 changelog.transport.map_or(FlexParam::Null, |s| FlexParam::Text(s.to_string())),
131 );
132 }
133
134 let mut configuration: Vec<(&str, &str)> = Vec::with_capacity(session_vars.len() + 3);
142 configuration.extend_from_slice(session_vars);
143 configuration.push((crate::changelog::CDC_MEDIATED_VAR, crate::changelog::CDC_MEDIATED_ON));
144 if adapter.mutation_timing_enabled {
145 configuration.push((
146 adapter.timing_variable_name.as_str(),
147 crate::changelog::CLOCK_TIMESTAMP_DIRECTIVE,
148 ));
149 }
150 if changelog.is_some()
156 && !configuration.iter().any(|(name, _)| *name == crate::changelog::STARTED_AT_VAR)
157 {
158 configuration.push((
159 crate::changelog::STARTED_AT_VAR,
160 crate::changelog::CLOCK_TIMESTAMP_DIRECTIVE,
161 ));
162 }
163
164 Self {
165 function_name,
166 sql,
167 args: flex_args,
168 configuration,
169 mechanism: if changelog.is_some() {
170 " (with change-log outbox)"
171 } else {
172 ""
173 },
174 derived: derived_cascade,
175 report_changes: report_changes.filter(|_| derived_cascade.is_none()),
176 }
177 }
178
179 fn params(&self) -> Vec<&(dyn tokio_postgres::types::ToSql + Sync)> {
180 self.args
181 .iter()
182 .map(|v| v as &(dyn tokio_postgres::types::ToSql + Sync))
183 .collect()
184 }
185
186 fn configuration_failed(&self, e: &tokio_postgres::Error) -> FraiseQLError {
187 let names: Vec<&str> = self.configuration.iter().map(|(name, _)| *name).collect();
188 crate::postgres::database_error(
189 format!("set_config({names:?}) failed: {}", pg_detail(e)),
190 e,
191 )
192 }
193
194 fn call_failed(&self, e: &tokio_postgres::Error) -> FraiseQLError {
195 crate::postgres::database_error(
196 format!(
197 "Function call {}{} failed: {}",
198 self.function_name,
199 self.mechanism,
200 pg_detail(e)
201 ),
202 e,
203 )
204 }
205}
206
207async fn run_functions_in_txn(
221 adapter: &PostgresAdapter,
222 requests: &[crate::traits::WriteRequest<'_>],
223 gate: crate::traits::BatchRowGate<'_>,
224 numbered: bool,
225) -> Result<Vec<Vec<RowMap>>> {
226 let Some(mode) = requests.first().map(|request| request.mode) else {
227 return Ok(Vec::new());
228 };
229 if requests.iter().any(|request| request.mode != mode) {
230 return Err(FraiseQLError::Validation {
231 message: "a batch of writes commits all of its calls or none: they must share one \
232 write mode"
233 .to_string(),
234 path: None,
235 });
236 }
237 let count = requests.len();
238 let at = |index: usize, error: FraiseQLError| {
239 if numbered {
240 error.in_batch_item(index, count)
241 } else {
242 error
243 }
244 };
245 let commit = matches!(mode, crate::traits::WriteMode::Commit);
246 if commit {
249 adapter.mark_write();
250 }
251 let calls: Vec<PreparedCall<'_>> =
252 requests.iter().map(|request| PreparedCall::new(adapter, request)).collect();
253 let configurations: Vec<_> =
254 calls.iter().map(|call| set_config_batch(&call.configuration)).collect();
255
256 let mut client = adapter.acquire_connection_with_retry().await?;
257 let mut statements = Vec::with_capacity(count);
262 for (index, (call, (configure_sql, _))) in calls.iter().zip(&configurations).enumerate() {
263 let stmt = prepare_cached_stmt(&client, call.sql.as_str())
264 .await
265 .map_err(|e| at(index, e))?;
266 let configure = client
267 .prepare_cached(configure_sql)
268 .await
269 .map_err(|e| at(index, call.configuration_failed(&e)))?;
270 let report = match call.report_changes {
271 Some(_) => Some(
272 client
273 .prepare_cached(CHANGED_ROWS_SQL)
274 .await
275 .map_err(|e| at(index, changes_report_failed(&e)))?,
276 ),
277 None => None,
278 };
279 statements.push((stmt, configure, report));
280 }
281 let mechanism = calls
282 .iter()
283 .find(|call| !call.mechanism.is_empty())
284 .map_or("", |call| call.mechanism);
285 let txn = client.build_transaction().start().await.map_err(|e| {
286 crate::postgres::database_error(
287 format!("Failed to start mutation{mechanism} transaction: {}", pg_detail(&e)),
288 &e,
289 )
290 })?;
291
292 let flight = |index: usize| {
301 let (call, (stmt, configure, report)) = (&calls[index], &statements[index]);
302 let configure_params = &configurations[index].1;
303 let txn = &txn;
304 async move {
305 let params = call.params();
306 let max_entities = call.report_changes.unwrap_or_default();
307 futures::join!(
308 txn.execute(configure, configure_params),
309 txn.query(stmt, params.as_slice()),
310 async {
311 match report {
312 Some(report) => Some(txn.query_one(report, &[&max_entities]).await),
313 None => None,
314 }
315 }
316 )
317 }
318 };
319 let settle = |index: usize,
323 (configured, called, reported): (
324 std::result::Result<u64, tokio_postgres::Error>,
325 std::result::Result<Vec<Row>, tokio_postgres::Error>,
326 Option<std::result::Result<Row, tokio_postgres::Error>>,
327 )| {
328 let call = &calls[index];
329 let txn = &txn;
330 async move {
331 configured.map_err(|e| call.configuration_failed(&e))?;
332 let rows = called.map_err(|e| call.call_failed(&e))?;
333 let mut results: Vec<RowMap> = rows.iter().map(row_to_map).collect();
334 if let Some(reported) = reported {
335 let report: serde_json::Value =
336 reported.map_err(|e| changes_report_failed(&e))?.get("report");
337 if let Some(first) = results.first_mut() {
338 first.insert(crate::traits::CHANGED_ROWS_KEY.to_string(), report);
339 }
340 }
341 if let Some(derived) = call.derived {
342 if let Some(first) = results.first_mut() {
343 if first.get("succeeded").and_then(serde_json::Value::as_bool) == Some(true) {
344 let report = derived_cascade_report(txn, derived).await?;
345 first.insert(crate::traits::DERIVED_CASCADE_KEY.to_string(), report);
346 }
347 }
348 }
349 Ok::<_, FraiseQLError>(results)
350 }
351 };
352
353 let answers: Vec<Option<_>> = if calls.iter().all(|call| call.derived.is_none()) {
356 in_order((0..count).map(flight).collect()).await.into_iter().map(Some).collect()
357 } else {
358 std::iter::repeat_with(|| None).take(count).collect()
359 };
360 let mut results = Vec::with_capacity(count);
361 for (index, answer) in answers.into_iter().enumerate() {
362 let answer = match answer {
363 Some(answer) => answer,
364 None => flight(index).await,
365 };
366 let rows = settle(index, answer).await.map_err(|e| at(index, e))?;
367
368 if let Err(refusal) = gate(index, &rows) {
373 txn.rollback().await.map_err(|e| {
374 crate::postgres::database_error(
375 format!("Failed to roll back refused mutation transaction: {}", pg_detail(&e)),
376 &e,
377 )
378 })?;
379 return Err(refusal);
380 }
381 results.push(rows);
382 }
383
384 if !commit {
385 txn.rollback().await.map_err(|e| {
387 crate::postgres::database_error(
388 format!("Failed to roll back dry-run transaction: {}", pg_detail(&e)),
389 &e,
390 )
391 })?;
392 return Ok(results);
393 }
394
395 txn.commit().await.map_err(|e| {
396 crate::postgres::database_error(
397 format!("Failed to commit mutation{mechanism} transaction: {}", pg_detail(&e)),
398 &e,
399 )
400 })?;
401 adapter.mark_write();
402
403 Ok(results)
404}
405
406async fn in_order<F: std::future::Future>(futures: Vec<F>) -> Vec<F::Output> {
409 let mut pending: Vec<_> =
410 futures.into_iter().map(|f| Box::pin(futures::future::maybe_done(f))).collect();
411 std::future::poll_fn(|cx| {
412 let mut done = true;
413 for future in &mut pending {
414 done &= std::future::Future::poll(future.as_mut(), cx).is_ready();
415 }
416 if done {
417 std::task::Poll::Ready(())
418 } else {
419 std::task::Poll::Pending
420 }
421 })
422 .await;
423 pending.iter_mut().filter_map(|future| future.as_mut().take_output()).collect()
424}
425
426const CHANGED_ROWS_SQL: &str =
428 "SELECT tviews.pg_tviews_flush_and_report($1, false, true) AS report";
429
430fn changes_report_failed(e: &tokio_postgres::Error) -> FraiseQLError {
431 crate::postgres::database_error(
432 format!(
433 "tviews.pg_tviews_flush_and_report() failed, asked for the rows this write changed \
434 to evict the cached reads of exactly those (is pg_tviews installed and \
435 preloaded?): {}",
436 pg_detail(e)
437 ),
438 e,
439 )
440}
441
442async fn derived_cascade_report(
449 txn: &deadpool_postgres::Transaction<'_>,
450 derived: &crate::traits::DerivedCascade<'_>,
451) -> Result<serde_json::Value> {
452 let report_failed = |e: &tokio_postgres::Error| {
453 crate::postgres::database_error(
454 format!(
455 "cascade_source = \"pg_tviews\": tviews.pg_tviews_flush_and_report() \
456 failed (is pg_tviews installed and preloaded?): {}",
457 pg_detail(e)
458 ),
459 e,
460 )
461 };
462 let flush = txn
463 .prepare_cached(
464 "SELECT tviews.pg_tviews_flush_and_report($1, false, true) AS report, \
465 to_char(now() AT TIME ZONE 'UTC', 'YYYY-MM-DD\"T\"HH24:MI:SS.US\"Z\"') AS at",
466 )
467 .await
468 .map_err(|e| report_failed(&e))?;
469 let row = txn
470 .query_one(&flush, &[&derived.max_entities])
471 .await
472 .map_err(|e| report_failed(&e))?;
473 let mut report: serde_json::Value = row.get("report");
474 let at: String = row.get("at");
475 let reported_id = |entry: &serde_json::Value| match &entry["id"] {
476 serde_json::Value::String(s) => s.clone(),
477 other => other.to_string(),
478 };
479
480 if let Some(updated) = report.get_mut("updated").and_then(serde_json::Value::as_array_mut) {
481 let mut ids_by_view: Vec<(&str, &str, Vec<FlexParam>)> = Vec::new();
483 for entry in updated.iter() {
484 let typename = entry["__typename"].as_str().unwrap_or_default();
485 let Some((name, view)) = derived.views.iter().find(|(name, _)| *name == typename)
486 else {
487 continue;
488 };
489 let id = FlexParam::Text(reported_id(entry));
490 match ids_by_view.iter_mut().find(|(n, ..)| n == name) {
491 Some((.., ids)) => ids.push(id),
492 None => ids_by_view.push((name, view, vec![id])),
493 }
494 }
495 let reads = ids_by_view.iter().map(|(typename, view, ids)| async move {
496 let read_failed = |e: &tokio_postgres::Error| {
497 crate::postgres::database_error(
498 format!(
499 "cascade_source = \"pg_tviews\": reading {typename} from {view} \
500 failed: {}",
501 pg_detail(e)
502 ),
503 e,
504 )
505 };
506 let sql = format!(
508 "SELECT id::text AS id, data FROM {} WHERE id = ANY($1)",
509 quote_postgres_identifier(view)
510 );
511 let statement = txn.prepare_cached(&sql).await.map_err(|e| read_failed(&e))?;
512 let rows = txn.query(&statement, &[ids]).await.map_err(|e| read_failed(&e))?;
513 let by_id: std::collections::HashMap<String, serde_json::Value> =
514 rows.iter().map(|r| (r.get("id"), r.get("data"))).collect();
515 Ok::<_, FraiseQLError>((*typename, by_id))
516 });
517 let read: Vec<(&str, std::collections::HashMap<String, serde_json::Value>)> =
518 futures::future::try_join_all(reads).await?;
519
520 for entry in updated.iter_mut() {
523 let typename = entry["__typename"].as_str().unwrap_or_default();
524 let entity = read
525 .iter()
526 .find(|(name, _)| *name == typename)
527 .and_then(|(_, by_id)| by_id.get(&reported_id(entry)))
528 .cloned()
529 .unwrap_or(serde_json::Value::Null);
530 entry["entity"] = entity;
531 }
532 }
533 if let Some(deleted) = report.get_mut("deleted").and_then(serde_json::Value::as_array_mut) {
534 for entry in deleted.iter_mut() {
535 entry["deletedAt"] = serde_json::Value::String(at.clone());
536 }
537 }
538 Ok(report)
539}
540
541const PG_UNDEFINED_COLUMN: &str = "42703";
543
544#[derive(Debug)]
572enum FlexParam {
573 Null,
575 Text(String),
578 Value(serde_json::Value),
580}
581
582fn aggregate_params(params: &[serde_json::Value]) -> Vec<FlexParam> {
588 params
589 .iter()
590 .map(|v| match v {
591 serde_json::Value::Null => FlexParam::Null,
592 value => FlexParam::Value(value.clone()),
593 })
594 .collect()
595}
596
597fn write_text(
600 text: &str,
601 ty: &tokio_postgres::types::Type,
602 out: &mut bytes::BytesMut,
603) -> std::result::Result<(), Box<dyn std::error::Error + Sync + Send>> {
604 use tokio_postgres::types::Type;
605 if *ty == Type::JSONB {
606 out.put_u8(1);
608 out.extend_from_slice(text.as_bytes());
609 } else if *ty == Type::UUID {
610 let uuid = uuid::Uuid::parse_str(text)?;
611 out.extend_from_slice(uuid.as_bytes());
612 } else if *ty == Type::INT4 {
613 let n: i32 = text.parse()?;
614 out.put_i32(n);
615 } else if *ty == Type::INT8 {
616 let n: i64 = text.parse()?;
617 out.put_i64(n);
618 } else if *ty == Type::BOOL {
619 let b: bool = text.parse()?;
620 out.put_u8(u8::from(b));
621 } else {
622 out.extend_from_slice(text.as_bytes());
625 }
626 Ok(())
627}
628
629fn write_array_literal(items: &[serde_json::Value], json_elements: bool, out: &mut String) {
634 out.push('{');
635 for (i, item) in items.iter().enumerate() {
636 if i > 0 {
637 out.push(',');
638 }
639 match item {
640 serde_json::Value::Null => out.push_str("NULL"),
641 serde_json::Value::Array(inner) if !json_elements => {
642 write_array_literal(inner, json_elements, out);
643 },
644 serde_json::Value::String(s) if !json_elements => quote_array_item(s, out),
645 other => quote_array_item(&other.to_string(), out),
646 }
647 }
648 out.push('}');
649}
650
651fn quote_array_item(item: &str, out: &mut String) {
652 out.push('"');
653 for c in item.chars() {
654 if c == '"' || c == '\\' {
655 out.push('\\');
656 }
657 out.push(c);
658 }
659 out.push('"');
660}
661
662fn array_element(ty: &tokio_postgres::types::Type) -> Option<&tokio_postgres::types::Type> {
664 use tokio_postgres::types::Kind;
665 match ty.kind() {
666 Kind::Array(element) => Some(element),
667 Kind::Domain(base) => array_element(base),
668 _ => None,
669 }
670}
671
672impl tokio_postgres::types::ToSql for FlexParam {
673 fn to_sql(
674 &self,
675 ty: &tokio_postgres::types::Type,
676 out: &mut bytes::BytesMut,
677 ) -> std::result::Result<tokio_postgres::types::IsNull, Box<dyn std::error::Error + Sync + Send>>
678 {
679 use tokio_postgres::types::{IsNull, Type};
680 match self {
681 Self::Null => Ok(IsNull::Yes),
682 Self::Text(s) => {
683 write_text(s, ty, out)?;
684 Ok(IsNull::No)
685 },
686 Self::Value(value) => {
687 if *ty == Type::JSONB {
688 out.put_u8(1);
689 serde_json::to_writer((&mut *out).writer(), value)?;
690 } else if *ty == Type::JSON {
691 serde_json::to_writer((&mut *out).writer(), value)?;
692 } else if let (Some(element), serde_json::Value::Array(items)) =
693 (array_element(ty), value)
694 {
695 let json_elements = [Type::JSONB, Type::JSON].contains(element);
696 let mut literal = String::new();
697 write_array_literal(items, json_elements, &mut literal);
698 out.extend_from_slice(literal.as_bytes());
699 } else if let serde_json::Value::String(s) = value {
700 write_text(s, ty, out)?;
701 } else {
702 write_text(&value.to_string(), ty, out)?;
705 }
706 Ok(IsNull::No)
707 },
708 }
709 }
710
711 fn accepts(_ty: &tokio_postgres::types::Type) -> bool {
712 true
714 }
715
716 fn encode_format(&self, ty: &tokio_postgres::types::Type) -> tokio_postgres::types::Format {
717 use tokio_postgres::types::{Format, Type};
718 if [
719 Type::JSONB,
720 Type::JSON,
721 Type::UUID,
722 Type::INT4,
723 Type::INT8,
724 Type::BOOL,
725 ]
726 .contains(ty)
727 {
728 Format::Binary
729 } else {
730 Format::Text
731 }
732 }
733
734 fn to_sql_checked(
735 &self,
736 ty: &tokio_postgres::types::Type,
737 out: &mut bytes::BytesMut,
738 ) -> std::result::Result<tokio_postgres::types::IsNull, Box<dyn std::error::Error + Sync + Send>>
739 {
740 self.to_sql(ty, out)
743 }
744}
745
746fn enrich_undefined_column_error(
754 err: FraiseQLError,
755 view: &str,
756 where_clause: Option<&WhereClause>,
757) -> FraiseQLError {
758 let FraiseQLError::Database { ref sql_state, .. } = err else {
759 return err;
760 };
761 if sql_state.as_deref() != Some(PG_UNDEFINED_COLUMN) {
762 return err;
763 }
764 let native_cols: Vec<&str> =
765 where_clause.map(|wc| wc.native_column_names()).unwrap_or_default();
766 if native_cols.is_empty() {
767 return err;
768 }
769 FraiseQLError::Database {
770 message: format!(
771 "Column(s) {:?} referenced as native column(s) on `{view}` do not exist. \
772 These columns were auto-inferred from ID/UUID-typed query arguments. \
773 Either add the column(s) to the table/view, or set \
774 `native_columns = {{}}` explicitly in your schema to disable inference.",
775 native_cols,
776 ),
777 sql_state: Some(PG_UNDEFINED_COLUMN.to_string()),
778 constraint: None,
779 }
780}
781
782struct PgEnumLabel(String);
789
790impl<'a> FromSql<'a> for PgEnumLabel {
791 fn from_sql(
792 _ty: &Type,
793 raw: &'a [u8],
794 ) -> std::result::Result<Self, Box<dyn std::error::Error + Sync + Send>> {
795 Ok(Self(std::str::from_utf8(raw)?.to_owned()))
796 }
797
798 fn accepts(ty: &Type) -> bool {
799 matches!(ty.kind(), Kind::Enum(_))
800 }
801}
802
803struct AnyCell;
809
810impl<'a> FromSql<'a> for AnyCell {
811 fn from_sql(
812 _ty: &Type,
813 _raw: &'a [u8],
814 ) -> std::result::Result<Self, Box<dyn std::error::Error + Sync + Send>> {
815 Ok(Self)
816 }
817
818 fn accepts(_ty: &Type) -> bool {
819 true
820 }
821}
822
823fn row_to_map(row: &Row) -> std::collections::HashMap<String, serde_json::Value> {
828 let mut map = std::collections::HashMap::new();
829 for (idx, column) in row.columns().iter().enumerate() {
830 map.insert(column.name().to_string(), decode_cell(row, idx));
831 }
832 map
833}
834
835pub(super) fn decode_cell(row: &Row, idx: usize) -> serde_json::Value {
846 let column = &row.columns()[idx];
847 if matches!(row.try_get::<_, Option<AnyCell>>(idx), Ok(None)) {
848 serde_json::Value::Null
850 } else if let Ok(v) = row.try_get::<_, i16>(idx) {
851 serde_json::json!(v)
858 } else if let Ok(v) = row.try_get::<_, i32>(idx) {
859 serde_json::json!(v)
860 } else if let Ok(v) = row.try_get::<_, i64>(idx) {
861 serde_json::json!(v)
862 } else if let Ok(v) = row.try_get::<_, f64>(idx) {
863 serde_json::json!(v)
864 } else if let Ok(v) = row.try_get::<_, String>(idx) {
865 serde_json::json!(v)
866 } else if let Ok(v) = row.try_get::<_, bool>(idx) {
867 serde_json::json!(v)
868 } else if let Ok(v) = row.try_get::<_, PgNumericText>(idx) {
869 let s = v.0;
876 serde_json::from_str::<serde_json::Value>(&s).unwrap_or(serde_json::Value::String(s))
877 } else if let Ok(v) = row.try_get::<_, uuid::Uuid>(idx) {
878 serde_json::json!(v.to_string())
881 } else if let Ok(v) = row.try_get::<_, chrono::DateTime<chrono::Utc>>(idx) {
882 serde_json::json!(v.to_rfc3339())
884 } else if let Ok(v) = row.try_get::<_, chrono::NaiveDateTime>(idx) {
885 serde_json::json!(v.to_string())
887 } else if let Ok(v) = row.try_get::<_, chrono::NaiveDate>(idx) {
888 serde_json::json!(v.to_string())
890 } else if let Ok(v) = row.try_get::<_, Vec<String>>(idx) {
891 serde_json::json!(v)
896 } else if let Ok(v) = row.try_get::<_, PgEnumLabel>(idx) {
897 serde_json::json!(v.0)
906 } else if let Ok(v) = row.try_get::<_, serde_json::Value>(idx) {
907 v
908 } else {
909 tracing::warn!(
913 column = %column.name(),
914 pg_type = %column.type_(),
915 "decode_cell: column type not representable as JSON; returning null"
916 );
917 serde_json::Value::Null
918 }
919}
920
921pub(super) async fn apply_session_vars(
928 txn: &deadpool_postgres::Transaction<'_>,
929 session_vars: &[(&str, &str)],
930) -> Result<()> {
931 if session_vars.is_empty() {
932 return Ok(());
933 }
934 let (sql, params) = set_config_batch(session_vars);
935 let applied = match txn.prepare_cached(&sql).await {
939 Ok(statement) => txn.execute(&statement, ¶ms).await,
940 Err(e) => Err(e),
941 };
942 applied.map_err(|e| {
943 let names: Vec<&str> = session_vars.iter().map(|(name, _)| *name).collect();
944 crate::postgres::database_error(
945 format!("set_config({names:?}) failed: {}", pg_detail(&e)),
946 &e,
947 )
948 })?;
949 Ok(())
950}
951
952fn set_config_batch<'a>(
959 session_vars: &'a [(&'a str, &'a str)],
960) -> (String, Vec<&'a (dyn tokio_postgres::types::ToSql + Sync)>) {
961 let mut sql = String::from("SELECT ");
962 let mut params: Vec<&(dyn tokio_postgres::types::ToSql + Sync)> =
963 Vec::with_capacity(session_vars.len() * 2);
964 for (index, (name, value)) in session_vars.iter().enumerate() {
965 if index > 0 {
966 sql.push_str(", ");
967 }
968 params.push(name);
969 let name_param = params.len();
970 if *value == crate::changelog::CLOCK_TIMESTAMP_DIRECTIVE {
971 let _ = write!(sql, "set_config(${name_param}, clock_timestamp()::text, true)");
972 } else {
973 params.push(value);
974 let _ = write!(sql, "set_config(${name_param}, ${}, true)", name_param + 1);
975 }
976 }
977 (sql, params)
978}
979
980pub(super) fn build_changelog_cte_sql(quoted_fn: &str, n_args: usize, pre_image: bool) -> String {
1012 let placeholders: Vec<String> = (1..=n_args).map(|i| format!("${i}")).collect();
1013 let object_type_idx = n_args + 1;
1014 let modification_type_idx = n_args + 2;
1015 let tenant_id_idx = n_args + 3;
1016 let trace_id_idx = n_args + 4;
1017 let schema_version_idx = n_args + 5;
1018 let trace_context_idx = n_args + 6;
1019 let actor_type_idx = n_args + 7;
1020 let acting_for_idx = n_args + 8;
1021 let transport_idx = n_args + 9;
1022 let started_var = crate::changelog::STARTED_AT_VAR;
1023 let duration = crate::changelog::duration_ms_sql(started_var);
1024 let calc_version = crate::changelog::DURATION_CALC_VERSION;
1025 let after_before_cols = if pre_image {
1034 "object_data, object_data_before"
1035 } else {
1036 "object_data"
1037 };
1038 let after_before_vals = if pre_image {
1039 "r.entity, r.entity_before"
1040 } else {
1041 "r.entity"
1042 };
1043 format!(
1044 "WITH r AS MATERIALIZED (SELECT * FROM {quoted_fn}({args})), \
1045 _changelog AS ( \
1046 INSERT INTO core.tb_entity_change_log \
1047 (object_type, modification_type, object_id, {after_before_cols}, \
1048 updated_fields, cascade, started_at, duration_ms, extra_metadata, \
1049 tenant_id, trace_id, schema_version, trace_context, \
1050 actor_type, acting_for, commit_time) \
1051 SELECT \
1052 COALESCE(r.entity_type, ${object_type_idx}), \
1053 ${modification_type_idx}, \
1054 r.entity_id, {after_before_vals}, r.updated_fields, r.cascade, \
1055 current_setting('{started_var}')::timestamptz, \
1056 {duration}, \
1057 jsonb_build_object('duration_calc_version', {calc_version}::int) \
1058 || CASE WHEN ${transport_idx}::text IS NULL THEN '{{}}'::jsonb \
1059 ELSE jsonb_build_object('transport', ${transport_idx}::text) END, \
1060 ${tenant_id_idx}::uuid, \
1061 ${trace_id_idx}, \
1062 ${schema_version_idx}, \
1063 ${trace_context_idx}::jsonb, \
1064 ${actor_type_idx}, \
1065 ${acting_for_idx}::uuid, \
1066 clock_timestamp() \
1067 FROM r \
1068 WHERE r.succeeded AND r.state_changed \
1069 RETURNING 1 \
1070 ) \
1071 SELECT * FROM r",
1072 args = placeholders.join(", "),
1073 )
1074}
1075
1076async fn prepare_cached_stmt(
1088 client: &deadpool_postgres::Client,
1089 sql: &str,
1090) -> Result<tokio_postgres::Statement> {
1091 client.prepare_cached(sql).await.map_err(|e| {
1092 let detail = pg_detail(&e);
1096 let hint = changelog_prepare_hint(&detail);
1097 crate::postgres::database_error(format!("Failed to prepare statement: {detail}{hint}"), &e)
1098 })
1099}
1100
1101fn changelog_prepare_hint(detail: &str) -> &'static str {
1111 if detail.contains("core.tb_entity_change_log") {
1112 "\nhint: the mutation change-log outbox table is not installed in this database — \
1113 run `fraiseql setup` (or apply the fraiseql-observers change-log contract \
1114 migration) before executing mutations"
1115 } else if detail.contains("column r.") {
1116 "\nhint: the mutation function does not return the v2.2 mutation_response row \
1117 (13 columns: succeeded, state_changed, …) that the change-log outbox reads. \
1118 `RETURNS SETOF v_*` and bare scalar returns are not supported — build the row \
1119 with fraiseql.mutation_ok()/fraiseql.mutation_err() (installed by `fraiseql \
1120 setup`); see docs/architecture/mutation-response.md"
1121 } else {
1122 ""
1123 }
1124}
1125
1126#[async_trait]
1130impl DatabaseAdapter for PostgresAdapter {
1131 fn applies_session_variables(&self) -> bool {
1133 true
1134 }
1135
1136 fn serves_reads_from_standbys(&self) -> bool {
1137 self.read_replicas.is_some()
1138 }
1139
1140 async fn execute_with_projection(
1141 &self,
1142 view: &str,
1143 projection: Option<&SqlProjectionHint>,
1144 where_clause: Option<&WhereClause>,
1145 limit: Option<u32>,
1146 offset: Option<u32>,
1147 order_by: Option<&[OrderByClause]>,
1148 ) -> Result<Vec<JsonbValue>> {
1149 self.execute_with_projection_impl(view, projection, where_clause, limit, offset, order_by)
1150 .await
1151 }
1152
1153 async fn execute_where_query(
1154 &self,
1155 view: &str,
1156 where_clause: Option<&WhereClause>,
1157 limit: Option<u32>,
1158 offset: Option<u32>,
1159 order_by: Option<&[OrderByClause]>,
1160 ) -> Result<Vec<JsonbValue>> {
1161 let (sql, typed_params) =
1162 build_where_select_sql_ordered(view, where_clause, limit, offset, order_by)?;
1163
1164 let param_refs = crate::types::as_sql_param_refs(&typed_params);
1165
1166 self.execute_raw(&sql, ¶m_refs, ReadRouting::Any)
1167 .await
1168 .map_err(|e| enrich_undefined_column_error(e, view, where_clause))
1169 }
1170
1171 async fn explain_where_query(
1172 &self,
1173 view: &str,
1174 where_clause: Option<&WhereClause>,
1175 limit: Option<u32>,
1176 offset: Option<u32>,
1177 ) -> Result<serde_json::Value> {
1178 let (select_sql, typed_params) = build_where_select_sql(view, where_clause, limit, offset)?;
1179 if select_sql.contains(';') {
1182 return Err(FraiseQLError::Validation {
1183 message: "EXPLAIN SQL must be a single statement".into(),
1184 path: None,
1185 });
1186 }
1187 let explain_sql = format!("EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON) {select_sql}");
1188
1189 let param_refs = crate::types::as_sql_param_refs(&typed_params);
1190
1191 let client = self.acquire_read_connection_with_retry(ReadRouting::Any).await?;
1194 let rows = client.query(explain_sql.as_str(), ¶m_refs).await.map_err(|e| {
1195 crate::postgres::database_error(
1196 format!("EXPLAIN ANALYZE failed: {}", pg_detail(&e)),
1197 &e,
1198 )
1199 })?;
1200
1201 if let Some(row) = rows.first() {
1202 let plan: serde_json::Value = row.try_get(0).map_err(|e| FraiseQLError::Database {
1203 message: format!("Failed to parse EXPLAIN output: {e}"),
1204 sql_state: None,
1205 constraint: None,
1206 })?;
1207 Ok(plan)
1208 } else {
1209 Ok(serde_json::Value::Null)
1210 }
1211 }
1212
1213 fn database_type(&self) -> DatabaseType {
1214 DatabaseType::PostgreSQL
1215 }
1216
1217 fn supports_composed_reads(&self) -> bool {
1219 true
1220 }
1221
1222 async fn tview_profiles(&self, sources: &[String]) -> Result<Vec<crate::traits::TviewProfile>> {
1223 let client = self.acquire_connection_with_retry().await?;
1224 crate::postgres::introspector::query_tview_profiles(&client, sources).await
1225 }
1226
1227 async fn schema_storage_bytes(&self, schema: &str) -> Result<Option<u64>> {
1228 let client = self.acquire_connection_with_retry().await?;
1229 let row = client
1233 .query_one(
1234 "SELECT COALESCE(sum(pg_total_relation_size(c.oid)), 0)::bigint FROM pg_class c \
1235 JOIN pg_namespace n ON n.oid = c.relnamespace WHERE n.nspname = $1 \
1236 AND c.relkind IN ('r', 'm')",
1237 &[&schema],
1238 )
1239 .await
1240 .map_err(|e| {
1241 crate::postgres::database_error(
1242 format!("measuring schema {schema:?}: {}", pg_detail(&e)),
1243 &e,
1244 )
1245 })?;
1246 let bytes: i64 = row.get(0);
1247 Ok(Some(u64::try_from(bytes).unwrap_or(0)))
1248 }
1249
1250 async fn describe_constraint(
1251 &self,
1252 violation: &fraiseql_error::ConstraintViolation,
1253 ) -> Result<crate::traits::ConstraintDescription> {
1254 let (Some(schema), Some(table)) = (&violation.schema, &violation.table) else {
1257 return Ok(crate::traits::ConstraintDescription {
1258 name: violation.name.clone(),
1259 columns: None,
1260 });
1261 };
1262 let client = self.acquire_connection_with_retry().await?;
1263 let name = match (&violation.name, &violation.column) {
1266 (Some(name), _) => Some(name.clone()),
1267 (None, Some(column)) => client
1268 .query_opt(
1269 "SELECT c.conname::text FROM pg_constraint c JOIN pg_attribute a ON \
1270 a.attrelid = c.conrelid WHERE c.conrelid = to_regclass(format('%I.%I', \
1271 $1::text, $2::text)) AND c.contype = 'n' AND a.attname = $3 AND c.conkey = \
1272 ARRAY[a.attnum]",
1273 &[schema, table, column],
1274 )
1275 .await
1276 .map_err(|e| {
1277 crate::postgres::database_error(
1278 format!("Failed to resolve a not-null constraint: {}", pg_detail(&e)),
1279 &e,
1280 )
1281 })?
1282 .map(|row| row.get(0)),
1283 (None, None) => None,
1284 };
1285 let Some(name) = name else {
1286 return Ok(crate::traits::ConstraintDescription::default());
1287 };
1288 let columns: Option<Vec<String>> = client
1293 .query_one(
1294 "WITH k AS ( \
1295 SELECT u.attnum, u.ord FROM pg_constraint c, \
1296 unnest(c.conkey) WITH ORDINALITY u(attnum, ord) \
1297 WHERE c.conrelid = to_regclass(format('%I.%I', $1::text, $2::text)) \
1298 AND c.conname = $3 \
1299 UNION ALL \
1300 SELECT u.attnum, u.ord FROM pg_index i, \
1301 unnest(i.indkey) WITH ORDINALITY u(attnum, ord) \
1302 WHERE i.indexrelid = to_regclass(format('%I.%I', $1::text, $3::text)) \
1303 AND i.indrelid = to_regclass(format('%I.%I', $1::text, $2::text)) \
1304 AND u.ord <= i.indnkeyatts \
1305 AND NOT EXISTS (SELECT 1 FROM pg_constraint c2 \
1306 WHERE c2.conrelid = i.indrelid AND c2.conname = $3)) \
1307 SELECT CASE WHEN count(*) = 0 OR bool_or(k.attnum = 0) THEN NULL \
1308 ELSE array_agg(a.attname::text ORDER BY k.ord) END \
1309 FROM k LEFT JOIN pg_attribute a \
1310 ON a.attrelid = to_regclass(format('%I.%I', $1::text, $2::text)) \
1311 AND a.attnum = k.attnum",
1312 &[schema, table, &name],
1313 )
1314 .await
1315 .map_err(|e| {
1316 crate::postgres::database_error(
1317 format!("Failed to resolve a constraint's columns: {}", pg_detail(&e)),
1318 &e,
1319 )
1320 })?
1321 .get(0);
1322 Ok(crate::traits::ConstraintDescription {
1323 name: Some(name),
1324 columns,
1325 })
1326 }
1327
1328 async fn health_check(&self) -> Result<()> {
1329 let client = self.acquire_connection_with_retry().await?;
1331
1332 client.query("SELECT 1", &[]).await.map_err(|e| {
1333 crate::postgres::database_error(format!("Health check failed: {}", pg_detail(&e)), &e)
1334 })?;
1335
1336 Ok(())
1337 }
1338
1339 #[allow(clippy::cast_possible_truncation)] fn pool_metrics(&self) -> PoolMetrics {
1341 let status = self.pool.status();
1342
1343 PoolMetrics {
1344 total_connections: status.size as u32,
1345 idle_connections: status.available as u32,
1346 active_connections: (status.size - status.available) as u32,
1347 waiting_requests: status.waiting as u32,
1348 }
1349 }
1350
1351 async fn execute_raw_query(
1356 &self,
1357 sql: &str,
1358 ) -> Result<Vec<std::collections::HashMap<String, serde_json::Value>>> {
1359 let client = self.acquire_connection_with_retry().await?;
1361
1362 let rows: Vec<Row> = client.query(sql, &[]).await.map_err(|e| {
1363 crate::postgres::database_error(
1364 format!("Query execution failed: {}", pg_detail(&e)),
1365 &e,
1366 )
1367 })?;
1368
1369 let results: Vec<std::collections::HashMap<String, serde_json::Value>> =
1371 rows.iter().map(row_to_map).collect();
1372
1373 Ok(results)
1374 }
1375
1376 async fn execute_parameterized_aggregate(
1377 &self,
1378 sql: &str,
1379 params: &[serde_json::Value],
1380 ) -> Result<Vec<std::collections::HashMap<String, serde_json::Value>>> {
1381 let typed = aggregate_params(params);
1382 let param_refs: Vec<&(dyn tokio_postgres::types::ToSql + Sync)> =
1383 typed.iter().map(|v| v as &(dyn tokio_postgres::types::ToSql + Sync)).collect();
1384
1385 let client = self.acquire_read_connection_with_retry(ReadRouting::Any).await?;
1387 let rows: Vec<Row> = client.query(sql, ¶m_refs).await.map_err(|e| {
1388 crate::postgres::database_error(
1389 format!("Parameterized aggregate query failed: {}", pg_detail(&e)),
1390 &e,
1391 )
1392 })?;
1393
1394 let results: Vec<std::collections::HashMap<String, serde_json::Value>> =
1395 rows.iter().map(row_to_map).collect();
1396
1397 Ok(results)
1398 }
1399
1400 async fn execute_parameterized_aggregate_with_session(
1401 &self,
1402 sql: &str,
1403 params: &[serde_json::Value],
1404 session_vars: &[(&str, &str)],
1405 routing: ReadRouting,
1406 ) -> Result<Vec<std::collections::HashMap<String, serde_json::Value>>> {
1407 if session_vars.is_empty() {
1408 return self.execute_parameterized_aggregate(sql, params).await;
1409 }
1410
1411 let typed = aggregate_params(params);
1412 let param_refs: Vec<&(dyn tokio_postgres::types::ToSql + Sync)> =
1413 typed.iter().map(|v| v as &(dyn tokio_postgres::types::ToSql + Sync)).collect();
1414
1415 let mut client = self.acquire_read_connection_with_retry(routing).await?;
1417 let txn = client.build_transaction().start().await.map_err(|e| {
1418 crate::postgres::database_error(
1419 format!("Failed to start session-var transaction: {}", pg_detail(&e)),
1420 &e,
1421 )
1422 })?;
1423 apply_session_vars(&txn, session_vars).await?;
1424 let rows: Vec<Row> = txn.query(sql, ¶m_refs).await.map_err(|e| {
1425 crate::postgres::database_error(
1426 format!("Parameterized aggregate query failed: {}", pg_detail(&e)),
1427 &e,
1428 )
1429 })?;
1430 txn.commit().await.map_err(|e| {
1431 crate::postgres::database_error(
1432 format!("Failed to commit session-var transaction: {}", pg_detail(&e)),
1433 &e,
1434 )
1435 })?;
1436
1437 Ok(rows.iter().map(row_to_map).collect())
1438 }
1439
1440 async fn execute_where_query_arc_with_session(
1446 &self,
1447 view: &str,
1448 where_clause: Option<&WhereClause>,
1449 limit: Option<u32>,
1450 offset: Option<u32>,
1451 order_by: Option<&[OrderByClause]>,
1452 session_vars: &[(&str, &str)],
1453 routing: ReadRouting,
1454 ) -> Result<Arc<Vec<JsonbValue>>> {
1455 let (sql, typed_params) =
1456 build_where_select_sql_ordered(view, where_clause, limit, offset, order_by)?;
1457 let param_refs = crate::types::as_sql_param_refs(&typed_params);
1458
1459 if session_vars.is_empty() {
1465 return self
1466 .execute_raw(&sql, ¶m_refs, routing)
1467 .await
1468 .map(Arc::new)
1469 .map_err(|e| enrich_undefined_column_error(e, view, where_clause));
1470 }
1471
1472 self.execute_raw_with_session(&sql, ¶m_refs, session_vars, routing)
1473 .await
1474 .map(Arc::new)
1475 .map_err(|e| enrich_undefined_column_error(e, view, where_clause))
1476 }
1477
1478 async fn count_where_query(
1484 &self,
1485 view: &str,
1486 where_clause: Option<&WhereClause>,
1487 session_vars: &[(&str, &str)],
1488 routing: ReadRouting,
1489 ) -> Result<u64> {
1490 let (sql, typed_params) = super::build_count_sql(view, where_clause)?;
1491 let param_refs = crate::types::as_sql_param_refs(&typed_params);
1492
1493 let row = if session_vars.is_empty() {
1496 let client = self.acquire_read_connection_with_retry(routing).await?;
1497 client.query_one(&sql, ¶m_refs).await.map_err(|e| {
1498 crate::postgres::database_error(
1499 format!("Count query failed: {}", pg_detail(&e)),
1500 &e,
1501 )
1502 })?
1503 } else {
1504 let mut client = self.acquire_read_connection_with_retry(routing).await?;
1507 let txn = client.build_transaction().start().await.map_err(|e| {
1508 crate::postgres::database_error(
1509 format!("Failed to start count session-var transaction: {}", pg_detail(&e)),
1510 &e,
1511 )
1512 })?;
1513 super::database::apply_session_vars(&txn, session_vars).await?;
1514 let row = txn.query_one(&sql, ¶m_refs).await.map_err(|e| {
1515 crate::postgres::database_error(
1516 format!("Count query failed: {}", pg_detail(&e)),
1517 &e,
1518 )
1519 })?;
1520 txn.commit().await.map_err(|e| {
1521 crate::postgres::database_error(
1522 format!("Failed to commit count session-var transaction: {}", pg_detail(&e)),
1523 &e,
1524 )
1525 })?;
1526 row
1527 };
1528
1529 let total: i64 = row.get(0);
1530 Ok(total.cast_unsigned())
1533 }
1534
1535 async fn execute_with_projection_arc_with_session(
1536 &self,
1537 request: &ProjectionRequest<'_>,
1538 session_vars: &[(&str, &str)],
1539 routing: ReadRouting,
1540 ) -> Result<Arc<Vec<JsonbValue>>> {
1541 if let Some(bound) = request.matched_up_to {
1544 let (page, params) = match request.projection {
1545 Some(projection) => build_projection_select_sql(
1546 projection,
1547 request.view,
1548 request.where_clause,
1549 request.limit,
1550 request.offset,
1551 request.order_by,
1552 )?,
1553 None => super::build_where_select_sql_ordered(
1554 request.view,
1555 request.where_clause,
1556 request.limit,
1557 request.offset,
1558 request.order_by,
1559 )?,
1560 };
1561 let (sql, typed_params) = super::with_matched_count(
1562 &page,
1563 params,
1564 request.view,
1565 request.where_clause,
1566 bound,
1567 )?;
1568 let param_refs = crate::types::as_sql_param_refs(&typed_params);
1569 if session_vars.is_empty() {
1570 return self.execute_raw(&sql, ¶m_refs, routing).await.map(Arc::new);
1571 }
1572 return self
1573 .execute_raw_with_session(&sql, ¶m_refs, session_vars, routing)
1574 .await
1575 .map(Arc::new);
1576 }
1577
1578 let Some(projection) = request.projection else {
1581 return self
1582 .execute_where_query_arc_with_session(
1583 request.view,
1584 request.where_clause,
1585 request.limit,
1586 request.offset,
1587 request.order_by,
1588 session_vars,
1589 routing,
1590 )
1591 .await;
1592 };
1593
1594 let (sql, typed_params) = build_projection_select_sql(
1595 projection,
1596 request.view,
1597 request.where_clause,
1598 request.limit,
1599 request.offset,
1600 request.order_by,
1601 )?;
1602 tracing::debug!("SQL with projection = {}", sql);
1603 let param_refs = crate::types::as_sql_param_refs(&typed_params);
1604
1605 if session_vars.is_empty() {
1608 return self.execute_raw(&sql, ¶m_refs, routing).await.map(Arc::new);
1609 }
1610
1611 self.execute_raw_with_session(&sql, ¶m_refs, session_vars, routing)
1612 .await
1613 .map(Arc::new)
1614 }
1615
1616 async fn execute_composed_with_session(
1623 &self,
1624 read: &ComposedLevel,
1625 session_vars: &[(&str, &str)],
1626 routing: ReadRouting,
1627 ) -> Result<Arc<Vec<JsonbValue>>> {
1628 let (sql, typed_params) = build_composed_select_sql(read)?;
1629 let param_refs = crate::types::as_sql_param_refs(&typed_params);
1630
1631 if session_vars.is_empty() {
1634 return self.execute_raw(&sql, ¶m_refs, routing).await.map(Arc::new);
1635 }
1636
1637 self.execute_raw_with_session(&sql, ¶m_refs, session_vars, routing)
1638 .await
1639 .map(Arc::new)
1640 }
1641
1642 async fn stream_with_projection(
1643 &self,
1644 request: &ProjectionRequest<'_>,
1645 session_vars: &[(&str, &str)],
1646 routing: ReadRouting,
1647 ) -> Result<JsonbRowStream> {
1648 let (sql, typed_params) = match request.projection {
1649 Some(projection) => build_projection_select_sql(
1650 projection,
1651 request.view,
1652 request.where_clause,
1653 request.limit,
1654 request.offset,
1655 request.order_by,
1656 )?,
1657 None => build_where_select_sql_ordered(
1658 request.view,
1659 request.where_clause,
1660 request.limit,
1661 request.offset,
1662 request.order_by,
1663 )?,
1664 };
1665
1666 super::streaming::stream_rows(self, sql, typed_params, session_vars, routing, |row, sql| {
1667 jsonb_cell(row, 0, sql)
1668 })
1669 .await
1670 .map_err(|e| enrich_undefined_column_error(e, request.view, request.where_clause))
1671 }
1672
1673 async fn stream_row_query(
1679 &self,
1680 view_name: &str,
1681 columns: &[crate::types::ColumnSpec],
1682 where_sql: Option<&str>,
1683 order_by: Option<&str>,
1684 limit: Option<u32>,
1685 offset: Option<u32>,
1686 ) -> Result<ColumnRowStream> {
1687 let sql = crate::traits::build_row_query_sql(view_name, where_sql, order_by, limit, offset);
1688 let columns = columns.to_vec();
1689
1690 super::streaming::stream_rows(
1691 self,
1692 sql,
1693 Vec::new(),
1694 &[],
1695 ReadRouting::Primary,
1696 move |row, _sql| Ok(crate::traits::row_to_column_values(&row_to_map(row), &columns)),
1697 )
1698 .await
1699 }
1700
1701 async fn execute_row_query_with_session(
1708 &self,
1709 view_name: &str,
1710 columns: &[crate::types::ColumnSpec],
1711 where_sql: Option<&str>,
1712 order_by: Option<&str>,
1713 limit: Option<u32>,
1714 offset: Option<u32>,
1715 session_vars: &[(&str, &str)],
1716 ) -> Result<Vec<Vec<crate::types::ColumnValue>>> {
1717 if session_vars.is_empty() {
1718 return self
1719 .execute_row_query(view_name, columns, where_sql, order_by, limit, offset)
1720 .await;
1721 }
1722
1723 let sql = crate::traits::build_row_query_sql(view_name, where_sql, order_by, limit, offset);
1724
1725 let mut client = self.acquire_connection_with_retry().await?;
1726 let txn = client.build_transaction().start().await.map_err(|e| {
1727 crate::postgres::database_error(
1728 format!("Failed to start row-read session-var transaction: {}", pg_detail(&e)),
1729 &e,
1730 )
1731 })?;
1732 apply_session_vars(&txn, session_vars).await?;
1733 let rows: Vec<Row> = txn.query(sql.as_str(), &[]).await.map_err(|e| {
1734 crate::postgres::database_error(
1735 format!("Row query execution failed: {}", pg_detail(&e)),
1736 &e,
1737 )
1738 })?;
1739 txn.commit().await.map_err(|e| {
1740 crate::postgres::database_error(
1741 format!("Failed to commit row-read session-var transaction: {}", pg_detail(&e)),
1742 &e,
1743 )
1744 })?;
1745
1746 Ok(rows
1747 .iter()
1748 .map(|row| crate::traits::row_to_column_values(&row_to_map(row), columns))
1749 .collect())
1750 }
1751
1752 async fn stream_row_query_with_session(
1757 &self,
1758 view_name: &str,
1759 columns: &[crate::types::ColumnSpec],
1760 where_sql: Option<&str>,
1761 order_by: Option<&str>,
1762 limit: Option<u32>,
1763 offset: Option<u32>,
1764 session_vars: &[(&str, &str)],
1765 ) -> Result<ColumnRowStream> {
1766 let sql = crate::traits::build_row_query_sql(view_name, where_sql, order_by, limit, offset);
1767 let columns = columns.to_vec();
1768
1769 super::streaming::stream_rows(
1770 self,
1771 sql,
1772 Vec::new(),
1773 session_vars,
1774 ReadRouting::Primary,
1775 move |row, _sql| Ok(crate::traits::row_to_column_values(&row_to_map(row), &columns)),
1776 )
1777 .await
1778 }
1779
1780 async fn explain_query(
1781 &self,
1782 sql: &str,
1783 _params: &[serde_json::Value],
1784 ) -> Result<serde_json::Value> {
1785 if sql.contains(';') {
1789 return Err(FraiseQLError::Validation {
1790 message: "EXPLAIN SQL must be a single statement".into(),
1791 path: None,
1792 });
1793 }
1794 let explain_sql = format!("EXPLAIN (ANALYZE false, FORMAT JSON) {sql}");
1795 let client = self.acquire_read_connection_with_retry(ReadRouting::Any).await?;
1797 let rows: Vec<Row> = client.query(explain_sql.as_str(), &[]).await.map_err(|e| {
1798 crate::postgres::database_error(format!("EXPLAIN failed: {}", pg_detail(&e)), &e)
1799 })?;
1800
1801 if let Some(row) = rows.first() {
1802 let plan: serde_json::Value = row.try_get(0).map_err(|e| FraiseQLError::Database {
1803 message: format!("Failed to parse EXPLAIN output: {e}"),
1804 sql_state: None,
1805 constraint: None,
1806 })?;
1807 Ok(plan)
1808 } else {
1809 Ok(serde_json::Value::Null)
1810 }
1811 }
1812
1813 async fn query_stats(&self, limit: u32) -> Result<Vec<crate::types::QueryStatEntry>> {
1814 self.pg_query_stats(limit).await
1815 }
1816
1817 async fn query_stats_by_id(&self, id: &str) -> Result<Option<crate::types::QueryStatEntry>> {
1818 self.pg_query_stats_by_id(id).await
1819 }
1820
1821 async fn reset_query_stats(&self) -> Result<()> {
1822 self.pg_reset_query_stats().await
1823 }
1824
1825 async fn execute_admin_sql(
1832 &self,
1833 request: &crate::traits::AdminSqlRequest,
1834 ) -> Result<crate::traits::AdminSqlOutcome> {
1835 super::admin_sql::execute_admin_sql_impl(self, request).await
1836 }
1837}
1838
1839#[async_trait]
1841impl Writer for PostgresAdapter {
1842 async fn execute_write(
1843 &self,
1844 request: &crate::traits::WriteRequest<'_>,
1845 gate: crate::traits::MutationRowGate<'_>,
1846 ) -> Result<Vec<std::collections::HashMap<String, serde_json::Value>>> {
1847 let mut rows =
1848 run_functions_in_txn(self, std::slice::from_ref(request), &|_, rows| gate(rows), false)
1849 .await?;
1850 Ok(rows.pop().unwrap_or_default())
1851 }
1852
1853 async fn execute_writes(
1854 &self,
1855 requests: &[crate::traits::WriteRequest<'_>],
1856 gate: crate::traits::BatchRowGate<'_>,
1857 ) -> Result<Vec<Vec<std::collections::HashMap<String, serde_json::Value>>>> {
1858 run_functions_in_txn(self, requests, gate, true).await
1859 }
1860}