1use std::fmt;
2use std::marker::PhantomData;
3use std::time::Duration;
4
5use futures_core::stream::BoxStream;
6use sqlx::postgres::PgRow;
7use sqlx::{Decode, FromRow, Postgres, Row, Type};
8
9use crate::cursor::{Cursor, CursorPage};
10use crate::exec;
11use crate::expr::Direction;
12use crate::expr::{Cond, IntoProjections, Projection};
13use crate::model::{push_columns, push_returning};
14use crate::sql::Sql;
15use crate::{Column, Error, Executor, Expr, Model, Order, Page, Result, Value};
16
17fn push_where<'a>(sql: &mut Sql, keyword: &str, filters: impl IntoIterator<Item = &'a Cond>) {
18 let mut filters = filters.into_iter().peekable();
19 if filters.peek().is_none() {
20 return;
21 }
22 sql.push(keyword);
23 sql.push_list(filters, " AND ", |sql, cond| cond.write(sql));
25}
26
27#[derive(Debug, Clone, Copy, PartialEq, Eq)]
30pub(crate) enum Trashed {
31 Exclude,
32 Include,
33 Only,
34}
35
36impl Trashed {
37 fn cond<M: Model>(self) -> Option<Cond> {
39 let column = M::DELETED_AT_COLUMN?;
40 match self {
41 Trashed::Exclude => Some(Column::<M>::new(column).is_null().cond),
42 Trashed::Only => Some(Column::<M>::new(column).is_not_null().cond),
43 Trashed::Include => None,
44 }
45 }
46}
47
48fn implicit<M: Model>(trashed: Trashed, scoped: bool, all_tenants: bool) -> Vec<Cond> {
51 let default = scoped.then(M::default_scope).flatten().map(|e| e.cond);
52 tenant_cond::<M>(all_tenants)
53 .into_iter()
54 .chain(trashed.cond::<M>())
55 .chain(default)
56 .collect()
57}
58
59fn tenant_cond<M: Model>(all_tenants: bool) -> Option<Cond> {
62 let column = M::TENANT_COLUMN.filter(|_| !all_tenants)?;
63 Some(match crate::tenant::current() {
64 Some(tenant) => Column::<M>::new(column).eq(tenant).cond,
65 None => {
66 tracing::warn!(
67 target: "rok_db::tenant",
68 table = M::TABLE,
69 "query on a tenant model outside `with_tenant`; matching no rows (use `all_tenants()` to opt out)"
70 );
71 Expr::<M>::none().cond
72 }
73 })
74}
75
76#[derive(Debug, Clone, Copy, PartialEq, Eq)]
78enum Lock {
79 Update,
80 Share,
81}
82
83pub struct Select<M> {
88 pub(crate) filters: Vec<Cond>,
89 pub(crate) order: Vec<Order<M>>,
90 pub(crate) group_by: Vec<(&'static str, &'static str)>,
91 pub(crate) having: Vec<Cond>,
92 limit: Option<u64>,
93 offset: Option<u64>,
94 lock: Option<Lock>,
95 trashed: Trashed,
96 scoped: bool,
97 primary: bool,
98 all_tenants: bool,
99 pub(crate) joins: Vec<JoinClause>,
100 _model: PhantomData<fn() -> M>,
101}
102
103#[derive(Debug, Clone)]
105pub(crate) struct JoinClause {
106 pub(crate) left: bool,
107 pub(crate) table: &'static str,
108 pub(crate) on: Cond,
109 pub(crate) scope: fn() -> Vec<Cond>,
112 pub(crate) multiplies: bool,
114}
115
116pub(crate) fn join_scope<N: Model>() -> Vec<Cond> {
118 implicit::<N>(Trashed::Exclude, true, false)
119}
120
121impl<M: Model> Default for Select<M> {
122 fn default() -> Self {
123 Self::new()
124 }
125}
126
127impl<M: Model> Select<M> {
128 pub fn new() -> Self {
130 Self {
131 filters: Vec::new(),
132 order: Vec::new(),
133 group_by: Vec::new(),
134 having: Vec::new(),
135 limit: None,
136 offset: None,
137 lock: None,
138 trashed: Trashed::Exclude,
139 scoped: true,
140 primary: false,
141 all_tenants: false,
142 joins: Vec::new(),
143 _model: PhantomData,
144 }
145 }
146
147 pub fn filter(mut self, expr: Expr<M>) -> Self {
149 self.filters.push(expr.cond);
150 self
151 }
152
153 pub fn all_tenants(mut self) -> Self {
156 self.all_tenants = true;
157 self
158 }
159
160 pub fn on_primary(mut self) -> Self {
163 self.primary = true;
164 self
165 }
166
167 pub(crate) fn use_replica(&self) -> bool {
170 !self.primary && self.lock.is_none()
171 }
172
173 pub fn scope(self, scope: impl FnOnce(Self) -> Self) -> Self {
182 scope(self)
183 }
184
185 pub fn unscoped(mut self) -> Self {
189 self.scoped = false;
190 self
191 }
192
193 pub fn with_trashed(mut self) -> Self {
196 self.trashed = Trashed::Include;
197 self
198 }
199
200 pub fn only_trashed(mut self) -> Self {
202 self.trashed = Trashed::Only;
203 self
204 }
205
206 pub fn filter_if(self, condition: bool, expr: impl FnOnce() -> Expr<M>) -> Self {
208 if condition { self.filter(expr()) } else { self }
209 }
210
211 pub fn filter_opt<T>(self, value: Option<T>, expr: impl FnOnce(T) -> Expr<M>) -> Self {
217 match value {
218 Some(v) => self.filter(expr(v)),
219 None => self,
220 }
221 }
222
223 pub fn order_by(mut self, order: impl Into<Order<M>>) -> Self {
226 self.order.push(order.into());
227 self
228 }
229
230 pub fn group_by(mut self, column: Column<M>) -> Self {
232 self.group_by.push((M::TABLE, column.name()));
233 self
234 }
235
236 pub fn having(mut self, expr: Expr<M>) -> Self {
239 self.having.push(expr.cond);
240 self
241 }
242
243 pub fn limit(mut self, limit: u64) -> Self {
245 self.limit = Some(limit);
246 self
247 }
248
249 pub fn offset(mut self, offset: u64) -> Self {
251 self.offset = Some(offset);
252 self
253 }
254
255 pub fn for_update(mut self) -> Self {
257 self.lock = Some(Lock::Update);
258 self
259 }
260
261 pub fn for_share(mut self) -> Self {
263 self.lock = Some(Lock::Share);
264 self
265 }
266
267 pub fn select(self, projections: impl IntoProjections<M>) -> Projected<M> {
276 Projected {
277 select: self,
278 items: projections.into_projections(),
279 }
280 }
281
282 pub fn memoize(self, ttl: Duration) -> Memoized<M> {
290 Memoized { select: self, ttl }
291 }
292
293 pub fn update(self) -> Update<M> {
295 Update {
296 filters: self.filters,
297 sets: Vec::new(),
298 trashed: self.trashed,
299 scoped: self.scoped,
300 all_tenants: self.all_tenants,
301 _model: PhantomData,
302 }
303 }
304
305 pub fn to_sql(&self) -> Sql {
307 let mut sql = self.new_sql();
308 if self.multiplies() {
309 self.write_distinct_rows(&mut sql, "", self.limit, self.offset);
310 return sql;
311 }
312 sql.push("SELECT ");
313 push_columns::<M>(&mut sql);
314 self.write_tail(&mut sql);
315 sql
316 }
317
318 pub(crate) fn new_sql(&self) -> Sql {
320 let mut sql = Sql::new();
321 sql.qualify = !self.joins.is_empty();
322 sql
323 }
324
325 fn multiplies(&self) -> bool {
328 self.group_by.is_empty() && self.joins.iter().any(|j| j.multiplies)
329 }
330
331 fn write_primary_keys(sql: &mut Sql) {
332 sql.push_list(M::PRIMARY_KEYS, ", ", |sql, c| {
333 sql.push_column(M::TABLE, c);
334 });
335 }
336
337 fn write_distinct_rows(
346 &self,
347 sql: &mut Sql,
348 head: &str,
349 limit: Option<u64>,
350 offset: Option<u64>,
351 ) {
352 sql.push("SELECT ")
353 .push(head)
354 .push(r#""__rok_d".* FROM (SELECT DISTINCT ON ("#);
355 Self::write_primary_keys(sql);
356 sql.push(") ");
357 push_columns::<M>(sql);
358 self.write_order_aliases(sql);
359 self.write_from_where(sql);
360 sql.push(" ORDER BY ");
361 Self::write_primary_keys(sql);
362 for o in &self.order {
363 sql.push(", ");
364 o.write(sql);
365 }
366 sql.push(r#") "__rok_d""#);
367 self.write_alias_order(sql, r#""__rok_d"."#);
368 if let Some(limit) = limit {
369 sql.push(&format!(" LIMIT {limit}"));
370 }
371 if let Some(offset) = offset {
372 sql.push(&format!(" OFFSET {offset}"));
373 }
374 }
375
376 fn write_order_aliases(&self, sql: &mut Sql) {
378 for (i, o) in self.order.iter().enumerate() {
379 sql.push(", ");
380 o.write_key(sql, "", None);
381 sql.push(" AS ").push_ident(&format!("__rok_o{i}"));
382 }
383 }
384
385 fn write_alias_order(&self, sql: &mut Sql, prefix: &str) {
387 if !self.order.is_empty() {
388 sql.push(" ORDER BY ")
389 .push_list(self.order.iter().enumerate(), ", ", |sql, (i, o)| {
390 sql.push(prefix).push_ident(&format!("__rok_o{i}"));
391 o.write_direction(sql);
392 });
393 }
394 }
395
396 pub(crate) fn write_tail(&self, sql: &mut Sql) {
398 self.write_from_where(sql);
399 if !self.group_by.is_empty() {
400 sql.push(" GROUP BY ")
401 .push_list(&self.group_by, ", ", |sql, (t, c)| {
402 sql.push_column(t, c);
403 });
404 }
405 push_where(sql, " HAVING ", &self.having);
406 self.write_order(sql, "");
407 if let Some(limit) = self.limit {
408 sql.push(&format!(" LIMIT {limit}"));
409 }
410 if let Some(offset) = self.offset {
411 sql.push(&format!(" OFFSET {offset}"));
412 }
413 match self.lock {
414 Some(Lock::Update) => sql.push(" FOR UPDATE"),
415 Some(Lock::Share) => sql.push(" FOR SHARE"),
416 None => sql,
417 };
418 }
419
420 fn write_from_where(&self, sql: &mut Sql) {
421 sql.push(" FROM ").push_ident(M::TABLE);
422 for join in &self.joins {
423 sql.push(if join.left {
424 " LEFT JOIN "
425 } else {
426 " INNER JOIN "
427 })
428 .push_ident(join.table)
429 .push(" ON ");
430 let scope = (join.scope)();
431 sql.push_list(
432 std::iter::once(&join.on).chain(&scope),
433 " AND ",
434 |sql, c| c.write(sql),
435 );
436 }
437 let implicit = implicit::<M>(self.trashed, self.scoped, self.all_tenants);
438 push_where(sql, " WHERE ", self.filters.iter().chain(&implicit));
439 }
440
441 pub(crate) fn write_exists_body(&self, sql: &mut Sql) {
443 sql.push("SELECT 1");
444 self.write_tail(sql);
445 }
446
447 fn write_order(&self, sql: &mut Sql, prefix: &str) {
450 if !self.order.is_empty() {
451 sql.push(" ORDER BY ")
452 .push_list(self.order.iter().enumerate(), ", ", |sql, (i, o)| {
453 let alias = (!prefix.is_empty()).then(|| format!("__rok_o{i}"));
454 o.write_key(sql, prefix, alias.as_deref());
455 o.write_direction(sql);
456 });
457 }
458 }
459
460 fn count_sql(&self) -> Sql {
461 let mut sql = self.new_sql();
462 self.write_count_head(&mut sql);
463 self.write_from_where(&mut sql);
464 sql
465 }
466
467 fn write_count_head(&self, sql: &mut Sql) {
469 if self.multiplies() {
470 sql.push("SELECT COUNT(DISTINCT ");
471 if M::PRIMARY_KEYS.len() > 1 {
472 sql.push("(");
473 Self::write_primary_keys(sql);
474 sql.push(")");
475 } else {
476 Self::write_primary_keys(sql);
477 }
478 sql.push(")");
479 } else {
480 sql.push("SELECT COUNT(*)");
481 }
482 }
483
484 fn exists_sql(&self) -> Sql {
485 let mut sql = self.new_sql();
486 sql.push("SELECT EXISTS(SELECT 1");
487 self.write_from_where(&mut sql);
488 sql.push(")");
489 sql
490 }
491
492 fn aggregate_sql(&self, projection: Projection<M>) -> Sql {
493 let mut sql = Sql::new();
494 sql.push("SELECT ");
495 projection.write(&mut sql);
496 self.write_from_where(&mut sql);
497 sql
498 }
499
500 pub async fn all<'e, E: Executor<'e>>(self, executor: E) -> Result<Vec<M>> {
502 exec::fetch_all(executor, &self.to_sql(), &[], self.use_replica()).await
503 }
504
505 pub async fn first<'e, E: Executor<'e>>(self, executor: E) -> Result<Option<M>> {
507 let replica = self.use_replica();
508 exec::fetch_optional(executor, &self.limit(1).to_sql(), &[], replica).await
509 }
510
511 pub async fn one<'e, E: Executor<'e>>(self, executor: E) -> Result<M> {
513 self.first(executor)
514 .await?
515 .ok_or_else(|| Error::not_found::<M>(None))
516 }
517
518 pub fn stream<'e, E: Executor<'e> + 'e>(self, executor: E) -> BoxStream<'e, Result<M>> {
529 let replica = self.use_replica();
530 exec::stream(executor, self.to_sql(), replica)
531 }
532
533 pub async fn count<'e, E: Executor<'e>>(self, executor: E) -> Result<i64> {
535 exec::fetch_scalar(executor, &self.count_sql(), self.use_replica()).await
536 }
537
538 pub async fn exists<'e, E: Executor<'e>>(self, executor: E) -> Result<bool> {
540 exec::fetch_scalar(executor, &self.exists_sql(), self.use_replica()).await
541 }
542
543 pub async fn sum<'e, E: Executor<'e>>(
547 self,
548 executor: E,
549 column: Column<M>,
550 ) -> Result<Option<i64>> {
551 let sql = self.aggregate_sql(column.sum().cast("BIGINT"));
552 exec::fetch_scalar(executor, &sql, self.use_replica()).await
553 }
554
555 pub async fn avg<'e, E: Executor<'e>>(
557 self,
558 executor: E,
559 column: Column<M>,
560 ) -> Result<Option<f64>> {
561 let sql = self.aggregate_sql(column.avg().cast("DOUBLE PRECISION"));
562 exec::fetch_scalar(executor, &sql, self.use_replica()).await
563 }
564
565 pub async fn min<'e, T, E>(self, executor: E, column: Column<M>) -> Result<Option<T>>
567 where
568 T: Type<Postgres> + for<'r> Decode<'r, Postgres> + Send + Unpin,
569 E: Executor<'e>,
570 {
571 exec::fetch_scalar(
572 executor,
573 &self.aggregate_sql(column.min()),
574 self.use_replica(),
575 )
576 .await
577 }
578
579 pub async fn max<'e, T, E>(self, executor: E, column: Column<M>) -> Result<Option<T>>
581 where
582 T: Type<Postgres> + for<'r> Decode<'r, Postgres> + Send + Unpin,
583 E: Executor<'e>,
584 {
585 exec::fetch_scalar(
586 executor,
587 &self.aggregate_sql(column.max()),
588 self.use_replica(),
589 )
590 .await
591 }
592
593 pub async fn paginate<'e, E: Executor<'e>>(
596 self,
597 executor: E,
598 page: u64,
599 per_page: u64,
600 ) -> Result<Page<M>> {
601 if per_page == 0 {
602 return Err(Error::InvalidQuery(
603 "`per_page` must be greater than 0".into(),
604 ));
605 }
606 let page = page.max(1);
607 let rows = exec::fetch_rows(
608 executor,
609 &self.paginate_sql(page, per_page),
610 &[],
611 self.use_replica(),
612 )
613 .await?;
614
615 let mut total = 0;
616 let mut items = Vec::with_capacity(rows.len());
617 for row in &rows {
618 total = row.try_get::<i64, _>("__rok_total")?;
619 if row.try_get::<Option<bool>, _>("__rok_present")?.is_some() {
620 items.push(M::from_row(row)?);
621 }
622 }
623 Ok(Page::new(items, total.max(0) as u64, page, per_page))
624 }
625
626 fn paginate_sql(&self, page: u64, per_page: u64) -> Sql {
627 if !self.joins.is_empty() {
628 return self.joined_paginate_sql(page, per_page);
629 }
630 let mut sql = Sql::new();
633 sql.push(r#"SELECT c."__rok_total", p.* FROM (SELECT COUNT(*) AS "__rok_total""#);
634 self.write_from_where(&mut sql);
635 sql.push(r#") c LEFT JOIN LATERAL (SELECT TRUE AS "__rok_present", "#);
636 push_columns::<M>(&mut sql);
637 for (i, o) in self.order.iter().enumerate() {
639 if o.column().is_none() {
640 sql.push(", ");
641 o.write_key(&mut sql, "", None);
642 sql.push(" AS ").push_ident(&format!("__rok_o{i}"));
643 }
644 }
645 self.write_from_where(&mut sql);
646 self.write_order(&mut sql, "");
647 let offset = (page - 1).saturating_mul(per_page);
648 sql.push(&format!(" LIMIT {per_page} OFFSET {offset}) p ON TRUE"));
649 self.write_order(&mut sql, "p.");
650 sql
651 }
652
653 fn joined_paginate_sql(&self, page: u64, per_page: u64) -> Sql {
657 let mut sql = self.new_sql();
658 sql.push(r#"SELECT c."__rok_total", p.* FROM ("#);
659 self.write_count_head(&mut sql);
660 sql.push(r#" AS "__rok_total""#);
661 self.write_from_where(&mut sql);
662 sql.push(") c LEFT JOIN LATERAL (");
663 let offset = (page - 1).saturating_mul(per_page);
664 let head = r#"TRUE AS "__rok_present", "#;
665 if self.multiplies() {
666 self.write_distinct_rows(&mut sql, head, Some(per_page), Some(offset));
667 } else {
668 sql.push("SELECT ").push(head);
669 push_columns::<M>(&mut sql);
670 self.write_order_aliases(&mut sql);
671 self.write_from_where(&mut sql);
672 self.write_order(&mut sql, "");
673 sql.push(&format!(" LIMIT {per_page} OFFSET {offset}"));
674 }
675 sql.push(") p ON TRUE");
676 self.write_alias_order(&mut sql, "p.");
677 sql
678 }
679
680 pub async fn delete<'e, E: Executor<'e>>(self, executor: E) -> Result<u64> {
685 exec::execute(executor, &self.delete_sql(), &[M::TABLE]).await
686 }
687
688 pub fn delete_sql(&self) -> Sql {
690 match M::DELETED_AT_COLUMN {
691 Some(deleted_at) => self
692 .clone()
693 .update()
694 .set_raw(Column::new(deleted_at), "now()", [] as [Value; 0])
695 .to_sql(),
696 None => self.force_delete_sql(),
697 }
698 }
699
700 pub async fn force_delete<'e, E: Executor<'e>>(self, executor: E) -> Result<u64> {
704 exec::execute(executor, &self.force_delete_sql(), &[M::TABLE]).await
705 }
706
707 pub(crate) fn force_delete_sql(&self) -> Sql {
708 let mut sql = Sql::new();
709 sql.push("DELETE");
710 self.write_from_where(&mut sql);
711 sql
712 }
713
714 pub async fn restore<'e, E: Executor<'e>>(self, executor: E) -> Result<u64> {
717 let Some(deleted_at) = M::DELETED_AT_COLUMN else {
718 return Err(Error::InvalidQuery(format!(
719 "`{}` has no soft-delete column",
720 M::TABLE
721 )));
722 };
723 self.only_trashed()
724 .update()
725 .set_raw(Column::new(deleted_at), "NULL", [] as [Value; 0])
726 .exec(executor)
727 .await
728 }
729
730 pub(crate) fn tables(&self) -> Vec<&'static str> {
732 std::iter::once(M::TABLE)
733 .chain(self.joins.iter().map(|j| j.table))
734 .collect()
735 }
736
737 pub(crate) fn key_subselect(&self) -> Select<M> {
741 let inner = self.clone();
742 let render = crate::expr::Render::new(move |sql: &mut Sql| {
743 let previous = std::mem::replace(&mut sql.qualify, true);
744 sql.push("SELECT ");
745 Self::write_primary_keys(sql);
746 inner.write_from_where(sql);
747 sql.qualify = previous;
748 });
749 let kind = if M::PRIMARY_KEYS.len() == 1 {
750 crate::expr::SubKind::In {
751 table: M::TABLE,
752 column: M::PRIMARY_KEY,
753 negated: false,
754 }
755 } else {
756 crate::expr::SubKind::InRow {
757 table: M::TABLE,
758 columns: M::PRIMARY_KEYS,
759 }
760 };
761 Select {
762 filters: vec![Cond::Sub { kind, render }],
763 trashed: self.trashed,
764 scoped: self.scoped,
765 all_tenants: self.all_tenants,
766 ..Select::new()
767 }
768 }
769
770 fn keyset_order(&self) -> Vec<(&'static str, Direction)> {
773 let mut order: Vec<_> = self
774 .order
775 .iter()
776 .filter_map(|o| o.column().map(|c| (c, o.direction)))
777 .collect();
778 for key in M::PRIMARY_KEYS {
779 if !order.iter().any(|(c, _)| c == key) {
780 order.push((key, Direction::Asc));
781 }
782 }
783 order
784 }
785
786 pub async fn cursor_paginate<'e, E: Executor<'e>>(
809 self,
810 executor: E,
811 after: Option<&Cursor>,
812 limit: u64,
813 ) -> Result<CursorPage<M>> {
814 if limit == 0 {
815 return Err(Error::InvalidQuery("`limit` must be greater than 0".into()));
816 }
817 if self.needs_wrapped_keyset() {
818 return self.wrapped_cursor_paginate(executor, after, limit).await;
819 }
820 let select = self.cursor_select(after, limit)?;
821 let order = select.keyset_order();
822 let mut items = select.all(executor).await?;
823 let next = if items.len() as u64 > limit {
824 items.truncate(limit as usize);
825 let last = items.last().expect("limit > 0");
826 let values = order
827 .iter()
828 .map(|(c, _)| {
829 last.value_of(c).ok_or_else(|| {
830 Error::InvalidQuery(format!("`{c}` is not a column of `{}`", M::TABLE))
831 })
832 })
833 .collect::<Result<Vec<_>>>()?;
834 Some(Cursor::new(values))
835 } else {
836 None
837 };
838 Ok(CursorPage { items, next })
839 }
840
841 fn needs_wrapped_keyset(&self) -> bool {
843 !self.joins.is_empty() || self.order.iter().any(|o| o.column().is_none())
844 }
845
846 fn keyset_orders(&self) -> Vec<Order<M>> {
848 let mut order = self.order.clone();
849 for key in M::PRIMARY_KEYS {
850 let present = order.iter().any(|o| {
851 matches!(o.target, crate::expr::OrderTarget::Column { table, name } if table == M::TABLE && name == *key)
852 });
853 if !present {
854 order.push(Column::<M>::new(key).asc());
855 }
856 }
857 order
858 }
859
860 fn wrapped_cursor_sql(&self, after: Option<&Cursor>, limit: u64) -> Result<(Sql, usize)> {
867 const ALIASES: [&str; 16] = [
868 "__rok_o0",
869 "__rok_o1",
870 "__rok_o2",
871 "__rok_o3",
872 "__rok_o4",
873 "__rok_o5",
874 "__rok_o6",
875 "__rok_o7",
876 "__rok_o8",
877 "__rok_o9",
878 "__rok_o10",
879 "__rok_o11",
880 "__rok_o12",
881 "__rok_o13",
882 "__rok_o14",
883 "__rok_o15",
884 ];
885 let mut keyed = self.clone();
886 keyed.order = self.keyset_orders();
887 let n = keyed.order.len();
888 if n > ALIASES.len() {
889 return Err(Error::InvalidQuery(
890 "too many sort keys for keyset pagination".into(),
891 ));
892 }
893 let mut sql = keyed.new_sql();
894 sql.qualify = true;
895 sql.push("SELECT * FROM (SELECT ");
896 let multiplies = keyed.multiplies();
897 if multiplies {
898 sql.push("DISTINCT ON (");
899 Self::write_primary_keys(&mut sql);
900 sql.push(") ");
901 }
902 push_columns::<M>(&mut sql);
903 keyed.write_order_aliases(&mut sql);
904 keyed.write_from_where(&mut sql);
905 if multiplies {
906 sql.push(" ORDER BY ");
907 Self::write_primary_keys(&mut sql);
908 for o in &keyed.order {
909 sql.push(", ");
910 o.write(&mut sql);
911 }
912 }
913 sql.push(r#") "__rok_k""#);
914 let key = |i: usize| crate::expr::Term::Column {
915 table: "__rok_k",
916 name: ALIASES[i],
917 };
918 if let Some(cursor) = after {
919 if cursor.values.len() != n {
920 return Err(Error::InvalidCursor(format!(
921 "expected {n} values, got {}",
922 cursor.values.len()
923 )));
924 }
925 let cmp = |i: usize, op: &'static str| Cond::Cmp {
926 term: key(i),
927 op,
928 value: cursor.values[i].clone(),
929 };
930 let branches = (0..n)
931 .map(|i| {
932 let step = match keyed.order[i].direction {
933 crate::expr::Direction::Asc => cmp(i, ">"),
934 crate::expr::Direction::Desc => cmp(i, "<"),
935 };
936 Cond::And((0..i).map(|j| cmp(j, "=")).chain([step]).collect())
937 })
938 .collect();
939 sql.push(" WHERE ");
940 Cond::Or(branches).write(&mut sql);
941 }
942 sql.push(" ORDER BY ").push_list(0..n, ", ", |sql, i| {
943 key(i).write(sql);
944 keyed.order[i].write_direction(sql);
945 });
946 sql.push(&format!(" LIMIT {}", limit + 1));
947 Ok((sql, n))
948 }
949
950 async fn wrapped_cursor_paginate<'e, E: Executor<'e>>(
951 self,
952 executor: E,
953 after: Option<&Cursor>,
954 limit: u64,
955 ) -> Result<CursorPage<M>> {
956 let (sql, n) = self.wrapped_cursor_sql(after, limit)?;
957 let rows = exec::fetch_rows(executor, &sql, &[], self.use_replica()).await?;
958 let more = rows.len() as u64 > limit;
959 let kept = &rows[..rows.len().min(limit as usize)];
960 let items = kept
961 .iter()
962 .map(M::from_row)
963 .collect::<std::result::Result<Vec<_>, _>>()?;
964 let next = match kept.last() {
965 Some(last) if more => Some(Cursor::new(
966 (0..n)
967 .map(|i| Value::from_row_column(last, &format!("__rok_o{i}")))
968 .collect::<Result<Vec<_>>>()?,
969 )),
970 _ => None,
971 };
972 Ok(CursorPage { items, next })
973 }
974
975 fn cursor_select(self, after: Option<&Cursor>, limit: u64) -> Result<Self> {
976 let order = self.keyset_order();
977 let mut select = self;
978 select.order = order
979 .iter()
980 .map(|(c, d)| match d {
981 Direction::Asc => Column::new(c).asc(),
982 Direction::Desc => Column::new(c).desc(),
983 })
984 .collect();
985 select.offset = None;
986 select.limit = Some(limit + 1);
987 if let Some(cursor) = after {
988 if cursor.values.len() != order.len() {
989 return Err(Error::InvalidCursor(format!(
990 "expected {} values, got {}",
991 order.len(),
992 cursor.values.len()
993 )));
994 }
995 let branches = (0..order.len()).map(|i| {
997 let eqs = (0..i).map(|j| Column::<M>::new(order[j].0).eq(cursor.values[j].clone()));
998 let (column, direction) = order[i];
999 let value = cursor.values[i].clone();
1000 let step = match direction {
1001 Direction::Asc => Column::<M>::new(column).gt(value),
1002 Direction::Desc => Column::<M>::new(column).lt(value),
1003 };
1004 Expr::all_of(eqs.chain([step]))
1005 });
1006 select = select.filter(Expr::any_of(branches));
1007 }
1008 Ok(select)
1009 }
1010}
1011
1012impl<M> Clone for Select<M> {
1013 fn clone(&self) -> Self {
1014 Self {
1015 filters: self.filters.clone(),
1016 order: self.order.clone(),
1017 group_by: self.group_by.clone(),
1018 having: self.having.clone(),
1019 limit: self.limit,
1020 offset: self.offset,
1021 lock: self.lock,
1022 trashed: self.trashed,
1023 scoped: self.scoped,
1024 primary: self.primary,
1025 all_tenants: self.all_tenants,
1026 joins: self.joins.clone(),
1027 _model: PhantomData,
1028 }
1029 }
1030}
1031
1032impl<M: Model> fmt::Debug for Select<M> {
1033 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1034 f.debug_tuple("Select").field(&self.to_sql()).finish()
1035 }
1036}
1037
1038pub struct Projected<M> {
1041 pub(crate) select: Select<M>,
1042 pub(crate) items: Vec<Projection<M>>,
1043}
1044
1045impl<M: Model> Projected<M> {
1046 pub fn to_sql(&self) -> Sql {
1048 let mut sql = self.select.new_sql();
1049 self.write_into(&mut sql);
1050 sql
1051 }
1052
1053 pub(crate) fn write_into(&self, sql: &mut Sql) {
1054 sql.push("SELECT ");
1055 sql.push_list(&self.items, ", ", |sql, p| p.write(sql));
1056 self.select.write_tail(sql);
1057 }
1058
1059 pub async fn fetch_all<'e, T, E>(self, executor: E) -> Result<Vec<T>>
1061 where
1062 T: for<'r> FromRow<'r, PgRow> + Send + Unpin,
1063 E: Executor<'e>,
1064 {
1065 exec::fetch_all(executor, &self.to_sql(), &[], self.select.use_replica()).await
1066 }
1067
1068 pub async fn fetch_optional<'e, T, E>(self, executor: E) -> Result<Option<T>>
1070 where
1071 T: for<'r> FromRow<'r, PgRow> + Send + Unpin,
1072 E: Executor<'e>,
1073 {
1074 let projected = Projected {
1075 select: self.select.limit(1),
1076 items: self.items,
1077 };
1078 let replica = projected.select.use_replica();
1079 exec::fetch_optional(executor, &projected.to_sql(), &[], replica).await
1080 }
1081
1082 pub async fn fetch_one<'e, T, E>(self, executor: E) -> Result<T>
1084 where
1085 T: for<'r> FromRow<'r, PgRow> + Send + Unpin,
1086 E: Executor<'e>,
1087 {
1088 self.fetch_optional(executor)
1089 .await?
1090 .ok_or_else(|| Error::not_found::<M>(None))
1091 }
1092
1093 pub async fn scalar<'e, T, E>(self, executor: E) -> Result<T>
1095 where
1096 T: Type<Postgres> + for<'r> Decode<'r, Postgres> + Send + Unpin,
1097 E: Executor<'e>,
1098 {
1099 exec::fetch_scalar(executor, &self.to_sql(), self.select.use_replica()).await
1100 }
1101
1102 pub fn stream<'e, T, E>(self, executor: E) -> BoxStream<'e, Result<T>>
1104 where
1105 T: for<'r> FromRow<'r, PgRow> + Send + Unpin + 'e,
1106 E: Executor<'e> + 'e,
1107 {
1108 let replica = self.select.use_replica();
1109 exec::stream(executor, self.to_sql(), replica)
1110 }
1111}
1112
1113impl<M> Clone for Projected<M> {
1114 fn clone(&self) -> Self {
1115 Self {
1116 select: self.select.clone(),
1117 items: self.items.clone(),
1118 }
1119 }
1120}
1121
1122impl<M: Model> fmt::Debug for Projected<M> {
1123 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1124 f.debug_tuple("Projected").field(&self.to_sql()).finish()
1125 }
1126}
1127
1128pub struct Memoized<M> {
1132 select: Select<M>,
1133 ttl: Duration,
1134}
1135
1136impl<M: Model + Clone> Memoized<M> {
1137 async fn cached<'e, T, E, F, Fut>(&self, executor: E, op: &str, sql: &Sql, run: F) -> Result<T>
1138 where
1139 T: Clone + Send + Sync + 'static,
1140 E: Executor<'e>,
1141 F: FnOnce(E) -> Fut,
1142 Fut: Future<Output = Result<T>>,
1143 {
1144 let cache = executor.__context().and_then(|c| c.cache.clone());
1145 let Some(cache) = cache else {
1146 return run(executor).await;
1147 };
1148 let key = format!(
1149 "{op}\u{1f}{}\u{1f}{}\u{1f}{:?}",
1150 std::any::type_name::<M>(),
1151 sql.as_str(),
1152 sql.params()
1153 );
1154 if let Some(hit) = cache.get::<T>(&key) {
1155 tracing::debug!(target: "rok_db::cache", table = M::TABLE, op, "cache hit");
1156 return Ok(hit);
1157 }
1158 let stamp = cache.stamp(&self.select.tables());
1159 let value = run(executor).await?;
1160 cache.put(key, stamp, self.ttl, value.clone());
1161 Ok(value)
1162 }
1163
1164 pub async fn all<'e, E: Executor<'e>>(self, executor: E) -> Result<Vec<M>> {
1166 let sql = self.select.to_sql();
1167 let replica = self.select.use_replica();
1168 self.cached(executor, "all", &sql, |e| {
1169 exec::fetch_all(e, &sql, &[], replica)
1170 })
1171 .await
1172 }
1173
1174 pub async fn first<'e, E: Executor<'e>>(self, executor: E) -> Result<Option<M>> {
1176 let sql = self.select.clone().limit(1).to_sql();
1177 self.cached(executor, "first", &sql, |e| {
1178 exec::fetch_optional(e, &sql, &[], self.select.use_replica())
1179 })
1180 .await
1181 }
1182
1183 pub async fn one<'e, E: Executor<'e>>(self, executor: E) -> Result<M> {
1185 self.first(executor)
1186 .await?
1187 .ok_or_else(|| Error::not_found::<M>(None))
1188 }
1189
1190 pub async fn count<'e, E: Executor<'e>>(self, executor: E) -> Result<i64> {
1192 let sql = self.select.count_sql();
1193 let replica = self.select.use_replica();
1194 self.cached(executor, "count", &sql, |e| {
1195 exec::fetch_scalar(e, &sql, replica)
1196 })
1197 .await
1198 }
1199
1200 pub async fn exists<'e, E: Executor<'e>>(self, executor: E) -> Result<bool> {
1202 let sql = self.select.exists_sql();
1203 let replica = self.select.use_replica();
1204 self.cached(executor, "exists", &sql, |e| {
1205 exec::fetch_scalar(e, &sql, replica)
1206 })
1207 .await
1208 }
1209
1210 pub async fn paginate<'e, E: Executor<'e>>(
1212 self,
1213 executor: E,
1214 page: u64,
1215 per_page: u64,
1216 ) -> Result<Page<M>> {
1217 let sql = self.select.paginate_sql(page.max(1), per_page);
1218 let select = self.select.clone();
1219 self.cached(executor, "paginate", &sql, |e| {
1220 select.paginate(e, page, per_page)
1221 })
1222 .await
1223 }
1224}
1225
1226impl<M> Clone for Memoized<M> {
1227 fn clone(&self) -> Self {
1228 Self {
1229 select: self.select.clone(),
1230 ttl: self.ttl,
1231 }
1232 }
1233}
1234
1235impl<M: Model> fmt::Debug for Memoized<M> {
1236 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1237 f.debug_struct("Memoized")
1238 .field("sql", &self.select.to_sql())
1239 .field("ttl", &self.ttl)
1240 .finish()
1241 }
1242}
1243
1244pub struct Update<M> {
1252 filters: Vec<Cond>,
1253 sets: Vec<(&'static str, Assign)>,
1254 trashed: Trashed,
1255 scoped: bool,
1256 all_tenants: bool,
1257 _model: PhantomData<fn() -> M>,
1258}
1259
1260#[derive(Debug, Clone)]
1261enum Assign {
1262 Value(Value),
1263 Raw(String, Vec<Value>),
1264}
1265
1266impl<M: Model> Update<M> {
1267 pub(crate) fn new() -> Self {
1268 Self {
1269 filters: Vec::new(),
1270 sets: Vec::new(),
1271 trashed: Trashed::Exclude,
1272 scoped: true,
1273 all_tenants: false,
1274 _model: PhantomData,
1275 }
1276 }
1277
1278 pub fn all_tenants(mut self) -> Self {
1280 self.all_tenants = true;
1281 self
1282 }
1283
1284 pub fn unscoped(mut self) -> Self {
1286 self.scoped = false;
1287 self
1288 }
1289
1290 pub fn filter(mut self, expr: Expr<M>) -> Self {
1292 self.filters.push(expr.cond);
1293 self
1294 }
1295
1296 pub fn with_trashed(mut self) -> Self {
1298 self.trashed = Trashed::Include;
1299 self
1300 }
1301
1302 pub fn set(mut self, column: Column<M>, value: impl Into<Value>) -> Self {
1304 self.sets.push((column.name(), Assign::Value(value.into())));
1305 self
1306 }
1307
1308 pub fn set_raw<V: Into<Value>>(
1314 mut self,
1315 column: Column<M>,
1316 sql: impl Into<String>,
1317 params: impl IntoIterator<Item = V>,
1318 ) -> Self {
1319 let params = params.into_iter().map(Into::into).collect();
1320 self.sets
1321 .push((column.name(), Assign::Raw(sql.into(), params)));
1322 self
1323 }
1324
1325 pub fn increment(self, column: Column<M>, by: impl Into<Value>) -> Self {
1327 let raw = format!("{} + ?", quoted(column.name()));
1328 self.set_raw(column, raw, [by.into()])
1329 }
1330
1331 pub fn decrement(self, column: Column<M>, by: impl Into<Value>) -> Self {
1333 let raw = format!("{} - ?", quoted(column.name()));
1334 self.set_raw(column, raw, [by.into()])
1335 }
1336
1337 pub(crate) fn has_sets(&self) -> bool {
1338 !self.sets.is_empty()
1339 }
1340
1341 pub(crate) fn into_select(self) -> Select<M> {
1342 Select {
1343 filters: self.filters,
1344 trashed: self.trashed,
1345 scoped: self.scoped,
1346 all_tenants: self.all_tenants,
1347 ..Select::new()
1348 }
1349 }
1350
1351 fn is_set(&self, column: &str) -> bool {
1352 self.sets.iter().any(|(c, _)| *c == column)
1353 }
1354
1355 pub fn to_sql(&self) -> Sql {
1357 let mut sql = Sql::new();
1358 self.write_into(&mut sql);
1359 sql
1360 }
1361
1362 pub(crate) fn write_into(&self, sql: &mut Sql) {
1363 sql.push("UPDATE ").push_ident(M::TABLE).push(" SET ");
1364 sql.push_list(&self.sets, ", ", |sql, (column, assign)| {
1365 sql.push_ident(column).push(" = ");
1366 match assign {
1367 Assign::Value(v) => sql.bind(v.clone()),
1368 Assign::Raw(raw, params) => sql.push_raw(raw, params),
1369 };
1370 });
1371 if let Some(updated_at) = M::UPDATED_AT_COLUMN {
1372 if !self.is_set(updated_at) {
1373 sql.push(", ").push_ident(updated_at).push(" = now()");
1374 }
1375 }
1376 if let Some(version) = M::VERSION_COLUMN {
1377 if !self.is_set(version) {
1378 sql.push(", ")
1379 .push_ident(version)
1380 .push(" = ")
1381 .push_ident(version)
1382 .push(" + 1");
1383 }
1384 }
1385 let implicit = implicit::<M>(self.trashed, self.scoped, self.all_tenants);
1386 push_where(sql, " WHERE ", self.filters.iter().chain(&implicit));
1387 }
1388
1389 fn check(&self) -> Result<()> {
1390 if let Some(tenant) = M::TENANT_COLUMN {
1391 if self.is_set(tenant) && crate::tenant::current().is_some() {
1392 return Err(Error::InvalidQuery(format!(
1393 "can't change the tenant column `{tenant}` inside a tenant scope"
1394 )));
1395 }
1396 }
1397 if self.sets.is_empty() {
1398 return Err(Error::InvalidQuery(format!(
1399 "UPDATE on `{}` has no columns to set",
1400 M::TABLE
1401 )));
1402 }
1403 Ok(())
1404 }
1405
1406 pub async fn exec<'e, E: Executor<'e>>(self, executor: E) -> Result<u64> {
1408 self.check()?;
1409 exec::execute(executor, &self.to_sql(), &[M::TABLE]).await
1410 }
1411
1412 pub async fn returning<'e, E: Executor<'e>>(self, executor: E) -> Result<Vec<M>> {
1414 self.check()?;
1415 let mut sql = self.to_sql();
1416 push_returning::<M>(&mut sql);
1417 exec::fetch_all(executor, &sql, &[M::TABLE], false).await
1418 }
1419
1420 pub(crate) async fn returning_one<'e, E: Executor<'e>>(self, executor: E) -> Result<Option<M>> {
1421 let mut sql = self.to_sql();
1422 push_returning::<M>(&mut sql);
1423 exec::fetch_optional(executor, &sql, &[M::TABLE], false).await
1424 }
1425}
1426
1427impl<M> Clone for Update<M> {
1428 fn clone(&self) -> Self {
1429 Self {
1430 filters: self.filters.clone(),
1431 sets: self.sets.clone(),
1432 trashed: self.trashed,
1433 scoped: self.scoped,
1434 all_tenants: self.all_tenants,
1435 _model: PhantomData,
1436 }
1437 }
1438}
1439
1440impl<M: Model> fmt::Debug for Update<M> {
1441 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1442 f.debug_tuple("Update").field(&self.to_sql()).finish()
1443 }
1444}
1445
1446fn quoted(ident: &str) -> String {
1447 let mut s = String::new();
1448 crate::sql::push_ident(&mut s, ident);
1449 s
1450}
1451
1452#[derive(Debug, Clone)]
1455pub(crate) enum ConflictTarget {
1456 None,
1457 Columns(Vec<&'static str>),
1458 Constraint(&'static str),
1459}
1460
1461#[derive(Debug, Clone)]
1462pub(crate) enum ConflictAction {
1463 Nothing,
1464 Update(Vec<&'static str>),
1465 UpdateAll,
1466}
1467
1468#[derive(Debug, Clone)]
1470pub(crate) struct Conflict {
1471 pub(crate) target: ConflictTarget,
1472 pub(crate) action: ConflictAction,
1473}
1474
1475impl Conflict {
1476 pub(crate) fn write<M: Model>(&self, sql: &mut Sql, inserted: &[&'static str]) -> Result<()> {
1478 sql.push(" ON CONFLICT");
1479 let target_columns: &[&str] = match &self.target {
1480 ConflictTarget::None => &[],
1481 ConflictTarget::Columns(columns) => {
1482 sql.push(" (")
1483 .push_list(columns, ", ", |sql, c| {
1484 sql.push_ident(c);
1485 })
1486 .push(")");
1487 columns
1488 }
1489 ConflictTarget::Constraint(name) => {
1490 sql.push(" ON CONSTRAINT ").push_ident(name);
1491 &[]
1492 }
1493 };
1494 let mut updates: Vec<&'static str> = match &self.action {
1495 ConflictAction::Nothing => {
1496 sql.push(" DO NOTHING");
1497 return Ok(());
1498 }
1499 ConflictAction::Update(columns) => columns.clone(),
1500 ConflictAction::UpdateAll => inserted
1501 .iter()
1502 .copied()
1503 .filter(|c| {
1504 !target_columns.contains(c)
1505 && !M::PRIMARY_KEYS.contains(c)
1506 && M::CREATED_AT_COLUMN != Some(*c)
1507 })
1508 .collect(),
1509 };
1510 if matches!(self.target, ConflictTarget::None) {
1511 return Err(Error::InvalidQuery(
1512 "ON CONFLICT DO UPDATE needs conflict columns or a constraint".into(),
1513 ));
1514 }
1515 updates.retain(|c| {
1518 M::VERSION_COLUMN != Some(*c)
1519 && M::UPDATED_AT_COLUMN != Some(*c)
1520 && M::TENANT_COLUMN != Some(*c)
1521 });
1522 sql.push(" DO UPDATE SET ");
1523 let mut first = true;
1524 let mut sep = |sql: &mut Sql| {
1525 if !std::mem::take(&mut first) {
1526 sql.push(", ");
1527 }
1528 };
1529 for column in &updates {
1530 sep(sql);
1531 sql.push_ident(column)
1532 .push(" = EXCLUDED.")
1533 .push_ident(column);
1534 }
1535 if let Some(updated_at) = M::UPDATED_AT_COLUMN {
1536 sep(sql);
1537 sql.push_ident(updated_at).push(" = now()");
1538 }
1539 if let Some(version) = M::VERSION_COLUMN {
1540 sep(sql);
1541 sql.push_ident(version)
1542 .push(" = ")
1543 .push_ident(M::TABLE)
1544 .push(".")
1545 .push_ident(version)
1546 .push(" + 1");
1547 }
1548 if first {
1549 sql.push_ident(M::PRIMARY_KEY)
1551 .push(" = ")
1552 .push_ident(M::TABLE)
1553 .push(".")
1554 .push_ident(M::PRIMARY_KEY);
1555 }
1556 if let Some(tenant) = M::TENANT_COLUMN {
1559 if inserted.contains(&tenant) {
1560 sql.push(" WHERE ")
1561 .push_ident(M::TABLE)
1562 .push(".")
1563 .push_ident(tenant)
1564 .push(" = EXCLUDED.")
1565 .push_ident(tenant);
1566 }
1567 }
1568 Ok(())
1569 }
1570}
1571
1572macro_rules! on_conflict_methods {
1573 () => {
1574 pub fn on_conflict(mut self, columns: impl IntoIterator<Item = Column<M>>) -> Self {
1579 self.conflict_target = Some(ConflictTarget::Columns(
1580 columns.into_iter().map(|c| c.name()).collect(),
1581 ));
1582 self
1583 }
1584
1585 pub fn on_constraint(mut self, name: &'static str) -> Self {
1587 self.conflict_target = Some(ConflictTarget::Constraint(name));
1588 self
1589 }
1590
1591 pub fn do_nothing(mut self) -> Self {
1594 self.conflict_action = Some(ConflictAction::Nothing);
1595 self
1596 }
1597
1598 pub fn do_update(mut self, columns: impl IntoIterator<Item = Column<M>>) -> Self {
1600 self.conflict_action = Some(ConflictAction::Update(
1601 columns.into_iter().map(|c| c.name()).collect(),
1602 ));
1603 self
1604 }
1605
1606 pub fn do_update_all(mut self) -> Self {
1611 self.conflict_action = Some(ConflictAction::UpdateAll);
1612 self
1613 }
1614
1615 fn conflict(&self) -> Result<Option<Conflict>> {
1616 match (&self.conflict_target, &self.conflict_action) {
1617 (None, None) => Ok(None),
1618 (target, Some(action)) => Ok(Some(Conflict {
1619 target: target.clone().unwrap_or(ConflictTarget::None),
1620 action: action.clone(),
1621 })),
1622 (Some(_), None) => Err(Error::InvalidQuery(
1623 "`on_conflict` needs `do_nothing`, `do_update` or `do_update_all`".into(),
1624 )),
1625 }
1626 }
1627 };
1628}
1629
1630pub struct Insert<M> {
1634 values: Vec<(&'static str, String, Vec<Value>)>,
1636 conflict_target: Option<ConflictTarget>,
1637 conflict_action: Option<ConflictAction>,
1638 _model: PhantomData<fn() -> M>,
1639}
1640
1641impl<M: Model> Insert<M> {
1642 pub(crate) fn new() -> Self {
1643 Self {
1644 values: Vec::new(),
1645 conflict_target: None,
1646 conflict_action: None,
1647 _model: PhantomData,
1648 }
1649 }
1650
1651 pub fn set(mut self, column: Column<M>, value: impl Into<Value>) -> Self {
1653 self.values
1654 .push((column.name(), "?".into(), vec![value.into()]));
1655 self
1656 }
1657
1658 pub fn set_raw<V: Into<Value>>(
1660 mut self,
1661 column: Column<M>,
1662 sql: impl Into<String>,
1663 params: impl IntoIterator<Item = V>,
1664 ) -> Self {
1665 let params = params.into_iter().map(Into::into).collect();
1666 self.values.push((column.name(), sql.into(), params));
1667 self
1668 }
1669
1670 on_conflict_methods!();
1671
1672 pub fn to_sql(&self) -> Sql {
1675 self.build(false).expect("lenient rendering never fails")
1676 }
1677
1678 fn build(&self, strict: bool) -> Result<Sql> {
1679 let mut values = self.values.clone();
1680 if let Some(column) = M::TENANT_COLUMN {
1681 if let Some(tenant) = crate::model::tenant_override::<M>(column) {
1682 values.retain(|(c, _, _)| *c != column);
1683 values.push((column, "?".into(), vec![tenant]));
1684 }
1685 }
1686 for ts in [M::CREATED_AT_COLUMN, M::UPDATED_AT_COLUMN]
1687 .into_iter()
1688 .flatten()
1689 {
1690 if !values.iter().any(|(c, _, _)| *c == ts) {
1691 values.push((ts, "now()".into(), Vec::new()));
1692 }
1693 }
1694 let mut sql = Sql::new();
1695 sql.push("INSERT INTO ").push_ident(M::TABLE);
1696 if values.is_empty() {
1697 sql.push(" DEFAULT VALUES");
1698 } else {
1699 sql.push(" (")
1700 .push_list(&values, ", ", |sql, (c, _, _)| {
1701 sql.push_ident(c);
1702 })
1703 .push(") VALUES (")
1704 .push_list(&values, ", ", |sql, (_, raw, params)| {
1705 sql.push_raw(raw, params);
1706 })
1707 .push(")");
1708 }
1709 let conflict = match self.conflict() {
1710 Ok(conflict) => conflict,
1711 Err(e) if strict => return Err(e),
1712 Err(_) => None,
1713 };
1714 if let Some(conflict) = conflict {
1715 let inserted: Vec<_> = values.iter().map(|(c, _, _)| *c).collect();
1716 let mut with_conflict = sql.clone();
1717 match conflict.write::<M>(&mut with_conflict, &inserted) {
1718 Ok(()) => sql = with_conflict,
1719 Err(e) if strict => return Err(e),
1720 Err(_) => {}
1721 }
1722 }
1723 push_returning::<M>(&mut sql);
1724 Ok(sql)
1725 }
1726
1727 pub async fn exec<'e, E: Executor<'e>>(self, executor: E) -> Result<M> {
1731 self.exec_optional(executor)
1732 .await?
1733 .ok_or_else(|| Error::not_found::<M>(None))
1734 }
1735
1736 pub async fn exec_optional<'e, E: Executor<'e>>(self, executor: E) -> Result<Option<M>> {
1739 exec::fetch_optional(executor, &self.build(true)?, &[M::TABLE], false).await
1740 }
1741}
1742
1743impl<M> Clone for Insert<M> {
1744 fn clone(&self) -> Self {
1745 Self {
1746 values: self.values.clone(),
1747 conflict_target: self.conflict_target.clone(),
1748 conflict_action: self.conflict_action.clone(),
1749 _model: PhantomData,
1750 }
1751 }
1752}
1753
1754impl<M: Model> fmt::Debug for Insert<M> {
1755 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1756 f.debug_tuple("Insert").field(&self.to_sql()).finish()
1757 }
1758}
1759
1760pub struct InsertMany<'a, M> {
1763 records: &'a [M],
1764 conflict_target: Option<ConflictTarget>,
1765 conflict_action: Option<ConflictAction>,
1766}
1767
1768impl<'a, M: Model> InsertMany<'a, M> {
1769 pub(crate) fn new(records: &'a [M]) -> Self {
1770 Self {
1771 records,
1772 conflict_target: None,
1773 conflict_action: None,
1774 }
1775 }
1776
1777 on_conflict_methods!();
1778
1779 pub fn to_sql(&self) -> Sql {
1782 let conflict = self.conflict().ok().flatten();
1783 crate::model::insert_sql(self.records, false, conflict.as_ref())
1784 .or_else(|_| crate::model::insert_sql(self.records, false, None))
1785 .expect("rendering without ON CONFLICT never fails")
1786 }
1787
1788 fn build(&self) -> Result<Sql> {
1789 crate::model::insert_sql(self.records, false, self.conflict()?.as_ref())
1790 }
1791
1792 pub async fn exec<'e, E: Executor<'e>>(self, executor: E) -> Result<Vec<M>> {
1798 if self.records.is_empty() {
1799 return Ok(Vec::new());
1800 }
1801 for record in self.records {
1802 crate::model::pre_insert(record)?;
1803 }
1804 let rows: Vec<M> = exec::fetch_all(executor, &self.build()?, &[M::TABLE], false).await?;
1805 for row in &rows {
1806 row.after_insert()?;
1807 }
1808 Ok(rows)
1809 }
1810}
1811
1812impl<M> Clone for InsertMany<'_, M> {
1813 fn clone(&self) -> Self {
1814 Self {
1815 records: self.records,
1816 conflict_target: self.conflict_target.clone(),
1817 conflict_action: self.conflict_action.clone(),
1818 }
1819 }
1820}
1821
1822impl<M: Model> fmt::Debug for InsertMany<'_, M> {
1823 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1824 f.debug_tuple("InsertMany").field(&self.to_sql()).finish()
1825 }
1826}
1827
1828#[doc(hidden)]
1829pub fn __paginate_sql<M: Model>(select: &Select<M>, page: u64, per_page: u64) -> Sql {
1830 select.paginate_sql(page, per_page)
1831}
1832
1833#[doc(hidden)]
1834pub fn __cursor_sql<M: Model>(
1835 select: Select<M>,
1836 after: Option<&Cursor>,
1837 limit: u64,
1838) -> Result<Sql> {
1839 if select.needs_wrapped_keyset() {
1840 return Ok(select.wrapped_cursor_sql(after, limit)?.0);
1841 }
1842 Ok(select.cursor_select(after, limit)?.to_sql())
1843}