1use std::collections::{HashMap, HashSet};
4use std::fmt;
5use std::hash::Hash;
6use std::marker::PhantomData;
7
8use crate::BoxFuture;
9use crate::col::Column;
10use crate::compile::select_partitioned;
11use crate::error::Error;
12use crate::executor::Executor;
13use crate::filter::Filter;
14use crate::model::Model;
15use crate::order::OrderBy;
16use crate::query::SelectQuery;
17use crate::related::Related;
18use crate::value::Encodable;
19
20async fn fetch_children<C, Key>(
29 exec: &dyn Executor,
30 child_key: Column<C, Key>,
31 filter: &Filter<C>,
32 order: &[OrderBy<C>],
33 limit: Option<u64>,
34 keys: &[Key],
35 full_table: bool,
36) -> Result<Vec<C>, Error>
37where
38 C: Model + Send + Unpin,
39 Key: Encodable + Eq + Hash + Clone + Send + Sync + 'static,
40{
41 let full_table_limit = exec.full_table_include_limit();
48 if full_table
49 && full_table_limit > 0
50 && filter.node == crate::filter::FilterNode::And(Vec::new())
51 && order.is_empty()
52 && limit.is_none()
53 {
54 let child_count = SelectQuery::<C>::new(exec).count().await?;
55 if child_count <= full_table_limit as i64 {
56 return SelectQuery::<C>::new(exec).fetch_all().await;
57 }
58 }
59
60 let keys = dedup(keys);
66 if keys.is_empty() {
67 return Ok(Vec::new());
68 }
69
70 let dialect = exec.dialect();
71 let caps = dialect.capabilities();
72 let chunk_size = (caps.max_query_params as usize).saturating_sub(10).max(1);
74
75 if let Some(n) = limit {
76 if !caps.window_functions {
77 return fetch_children_per_parent(exec, child_key, filter, order, n, &keys).await;
78 }
79
80 let mut all = Vec::new();
81 for chunk in keys.chunks(chunk_size) {
82 let combined = filter
85 .clone()
86 .and(crate::model::live_rows::<C>())
87 .and(child_key.in_set(chunk.iter().copied().cloned().collect::<Vec<_>>()));
88 let compiled = select_partitioned::<C>(
89 dialect,
90 C::TABLE,
91 child_key.column,
92 &combined.node,
93 order,
94 n,
95 );
96 let batch = exec.fetch_all_raw(compiled.sql, compiled.binds).await?;
97 all.extend(crate::executor::decode_rows::<C>(batch)?);
98 }
99 return Ok(all);
100 }
101
102 let mut all = Vec::new();
103 for chunk in keys.chunks(chunk_size) {
104 let mut q = SelectQuery::<C>::new(exec)
105 .filter(child_key.in_set(chunk.iter().copied().cloned().collect::<Vec<_>>()));
106 if filter.node != crate::filter::FilterNode::And(Vec::new()) {
107 q = q.filter(filter.clone());
108 }
109 for o in order {
110 q = q.order_by(o.clone());
111 }
112 all.extend(q.fetch_all().await?);
113 }
114 Ok(all)
115}
116
117async fn fetch_children_per_parent<C, Key>(
122 exec: &dyn Executor,
123 child_key: Column<C, Key>,
124 filter: &Filter<C>,
125 order: &[OrderBy<C>],
126 limit: u64,
127 keys: &[&Key],
128) -> Result<Vec<C>, Error>
129where
130 C: Model + Send + Unpin,
131 Key: Encodable + Clone + Send + Sync + 'static,
132{
133 let mut all = Vec::new();
134 for key in keys {
135 let mut q = SelectQuery::<C>::new(exec).filter(child_key.eq((*key).clone()));
136 if filter.node != crate::filter::FilterNode::And(Vec::new()) {
137 q = q.filter(filter.clone());
138 }
139 for o in order {
140 q = q.order_by(o.clone());
141 }
142 all.extend(q.limit(limit).fetch_all().await?);
143 }
144 Ok(all)
145}
146
147fn dedup<Key: Eq + Hash>(keys: &[Key]) -> Vec<&Key> {
152 let mut seen = HashSet::with_capacity(keys.len());
153 keys.iter().filter(|k| seen.insert(*k)).collect()
154}
155
156pub trait IncludeSet<M: Model> {
161 fn load<'a>(
168 &'a self,
169 exec: &'a dyn Executor,
170 parents: &'a mut [M],
171 full_table: bool,
172 ) -> BoxFuture<'a, Result<(), Error>>;
173}
174
175impl<M: Model> IncludeSet<M> for () {
176 fn load<'a>(
177 &'a self,
178 _exec: &'a dyn Executor,
179 _parents: &'a mut [M],
180 _full_table: bool,
181 ) -> BoxFuture<'a, Result<(), Error>> {
182 Box::pin(async { Ok(()) })
183 }
184}
185
186pub struct IncludeList<'db, M, C, Key, NI = ()> {
188 pub get: fn(&M) -> Key,
190 pub set: fn(&mut M, Related<Vec<C>>),
192 pub child_key: Column<C, Key>,
194 pub child_key_get: fn(&C) -> Key,
196 pub filter: Filter<C>,
198 pub order: Vec<OrderBy<C>>,
200 pub limit: Option<u64>,
202 pub nested: NI,
204 _marker: PhantomData<fn() -> &'db ()>,
205}
206
207impl<'db, M, C, Key, NI> Clone for IncludeList<'db, M, C, Key, NI>
208where
209 NI: Clone,
210{
211 fn clone(&self) -> Self {
212 Self {
213 get: self.get,
214 set: self.set,
215 child_key: self.child_key,
216 child_key_get: self.child_key_get,
217 filter: self.filter.clone(),
218 order: self.order.clone(),
219 limit: self.limit,
220 nested: self.nested.clone(),
221 _marker: PhantomData,
222 }
223 }
224}
225
226impl<'db, M, C, Key, NI> fmt::Debug for IncludeList<'db, M, C, Key, NI>
227where
228 NI: fmt::Debug,
229{
230 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
231 f.debug_struct("IncludeList")
232 .field("child_key", &self.child_key)
233 .field("filter", &self.filter)
234 .field("order", &self.order)
235 .field("limit", &self.limit)
236 .field("nested", &self.nested)
237 .finish()
238 }
239}
240
241impl<'db, M, C, Key> IncludeList<'db, M, C, Key, ()>
242where
243 M: Model,
244 C: Model,
245{
246 pub const fn new(
248 get: fn(&M) -> Key,
249 set: fn(&mut M, Related<Vec<C>>),
250 child_key: Column<C, Key>,
251 child_key_get: fn(&C) -> Key,
252 ) -> Self {
253 Self {
254 get,
255 set,
256 child_key,
257 child_key_get,
258 filter: Filter::new(crate::filter::FilterNode::And(Vec::new())),
259 order: Vec::new(),
260 limit: None,
261 nested: (),
262 _marker: PhantomData,
263 }
264 }
265}
266
267impl<'db, M, C, Key, NI> IncludeList<'db, M, C, Key, NI>
268where
269 M: Model,
270 C: Model,
271{
272 pub fn filter(mut self, f: Filter<C>) -> Self {
274 self.filter = self.filter.and(f);
275 self
276 }
277
278 pub fn order_by(mut self, o: OrderBy<C>) -> Self {
280 self.order.push(o);
281 self
282 }
283
284 pub fn take(mut self, n: u64) -> Self {
286 self.limit = Some(n);
287 self
288 }
289
290 pub fn include<J: IncludeSet<C>>(self, include: J) -> IncludeList<'db, M, C, Key, J> {
292 IncludeList {
293 get: self.get,
294 set: self.set,
295 child_key: self.child_key,
296 child_key_get: self.child_key_get,
297 filter: self.filter,
298 order: self.order,
299 limit: self.limit,
300 nested: include,
301 _marker: PhantomData,
302 }
303 }
304}
305
306impl<'db, M, C, Key, NI> IncludeSet<M> for IncludeList<'db, M, C, Key, NI>
307where
308 M: Model + Send + Unpin,
309 C: Model + Clone + Send + Unpin,
312 Key: Encodable + Eq + Hash + Clone + Send + Sync + 'static,
313 NI: IncludeSet<C> + Sync,
314{
315 fn load<'a>(
316 &'a self,
317 exec: &'a dyn Executor,
318 parents: &'a mut [M],
319 full_table: bool,
320 ) -> BoxFuture<'a, Result<(), Error>> {
321 Box::pin(async move {
322 if parents.is_empty() {
323 return Ok(());
324 }
325
326 let keys: Vec<Key> = parents.iter().map(self.get).collect();
327 let mut children = fetch_children(
328 exec,
329 self.child_key,
330 &self.filter,
331 &self.order,
332 self.limit,
333 &keys,
334 full_table,
335 )
336 .await?;
337
338 let child_full_table = full_table
341 && self.filter.node == crate::filter::FilterNode::And(Vec::new())
342 && self.order.is_empty()
343 && self.limit.is_none();
344 self.nested
345 .load(exec, &mut children, child_full_table)
346 .await?;
347
348 let bucket_hint = children.len() / parents.len();
354 let mut parent_index: HashMap<Key, Vec<usize>> = HashMap::with_capacity(parents.len());
355 for (i, parent) in parents.iter().enumerate() {
356 parent_index.entry((self.get)(parent)).or_default().push(i);
357 }
358
359 let mut buckets: Vec<Vec<C>> =
360 std::iter::repeat_with(|| Vec::with_capacity(bucket_hint))
361 .take(parents.len())
362 .collect();
363
364 for child in children {
365 if let Some(indices) = parent_index.get(&(self.child_key_get)(&child)) {
366 let mut iter = indices.iter();
367 if let Some(&first) = iter.next() {
368 for &idx in iter {
371 if let Some(bucket) = buckets.get_mut(idx) {
372 bucket.push(child.clone());
373 }
374 }
375 if let Some(bucket) = buckets.get_mut(first) {
376 bucket.push(child);
377 }
378 }
379 }
380 }
381
382 for (parent, bucket) in parents.iter_mut().zip(buckets) {
383 (self.set)(parent, Related::Loaded(bucket));
384 }
385
386 Ok(())
387 })
388 }
389}
390
391pub struct IncludeOne<'db, M, C, Key, NI = ()> {
393 pub get: fn(&M) -> Key,
395 pub set: fn(&mut M, Related<Option<C>>),
397 pub child_key: Column<C, Key>,
399 pub child_key_get: fn(&C) -> Key,
401 pub filter: Filter<C>,
403 pub order: Vec<OrderBy<C>>,
405 pub limit: Option<u64>,
407 pub nested: NI,
409 _marker: PhantomData<fn() -> &'db ()>,
410}
411
412impl<'db, M, C, Key, NI> Clone for IncludeOne<'db, M, C, Key, NI>
413where
414 NI: Clone,
415{
416 fn clone(&self) -> Self {
417 Self {
418 get: self.get,
419 set: self.set,
420 child_key: self.child_key,
421 child_key_get: self.child_key_get,
422 filter: self.filter.clone(),
423 order: self.order.clone(),
424 limit: self.limit,
425 nested: self.nested.clone(),
426 _marker: PhantomData,
427 }
428 }
429}
430
431impl<'db, M, C, Key, NI> fmt::Debug for IncludeOne<'db, M, C, Key, NI>
432where
433 NI: fmt::Debug,
434{
435 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
436 f.debug_struct("IncludeOne")
437 .field("child_key", &self.child_key)
438 .field("filter", &self.filter)
439 .field("order", &self.order)
440 .field("limit", &self.limit)
441 .field("nested", &self.nested)
442 .finish()
443 }
444}
445
446impl<'db, M, C, Key> IncludeOne<'db, M, C, Key, ()>
447where
448 M: Model,
449 C: Model,
450{
451 pub const fn new(
453 get: fn(&M) -> Key,
454 set: fn(&mut M, Related<Option<C>>),
455 child_key: Column<C, Key>,
456 child_key_get: fn(&C) -> Key,
457 ) -> Self {
458 Self {
459 get,
460 set,
461 child_key,
462 child_key_get,
463 filter: Filter::new(crate::filter::FilterNode::And(Vec::new())),
464 order: Vec::new(),
465 limit: None,
466 nested: (),
467 _marker: PhantomData,
468 }
469 }
470}
471
472impl<'db, M, C, Key, NI> IncludeOne<'db, M, C, Key, NI>
473where
474 M: Model,
475 C: Model,
476{
477 pub fn filter(mut self, f: Filter<C>) -> Self {
479 self.filter = self.filter.and(f);
480 self
481 }
482
483 pub fn order_by(mut self, o: OrderBy<C>) -> Self {
485 self.order.push(o);
486 self
487 }
488
489 pub fn take(mut self, n: u64) -> Self {
491 self.limit = Some(n);
492 self
493 }
494
495 pub fn include<J: IncludeSet<C>>(self, include: J) -> IncludeOne<'db, M, C, Key, J> {
497 IncludeOne {
498 get: self.get,
499 set: self.set,
500 child_key: self.child_key,
501 child_key_get: self.child_key_get,
502 filter: self.filter,
503 order: self.order,
504 limit: self.limit,
505 nested: include,
506 _marker: PhantomData,
507 }
508 }
509}
510
511pub struct IncludeMany<'db, M, C, J, Key, CKey, NI = ()> {
516 pub get: fn(&M) -> Key,
518 pub set: fn(&mut M, Related<Vec<C>>),
520 pub join_owner_get: fn(&J) -> Key,
522 pub join_target_get: fn(&J) -> CKey,
524 pub child_key_get: fn(&C) -> CKey,
526 pub join_owner_col: Column<J, Key>,
528 pub join_target_col: Column<J, CKey>,
530 pub target_pk: Column<C, CKey>,
532 pub filter: Filter<C>,
534 pub order: Vec<OrderBy<C>>,
536 pub limit: Option<u64>,
538 pub nested: NI,
540 _marker: PhantomData<fn() -> &'db ()>,
541}
542
543impl<'db, M, C, J, Key, CKey, NI> Clone for IncludeMany<'db, M, C, J, Key, CKey, NI>
544where
545 NI: Clone,
546{
547 fn clone(&self) -> Self {
548 Self {
549 get: self.get,
550 set: self.set,
551 join_owner_get: self.join_owner_get,
552 join_target_get: self.join_target_get,
553 child_key_get: self.child_key_get,
554 join_owner_col: self.join_owner_col,
555 join_target_col: self.join_target_col,
556 target_pk: self.target_pk,
557 filter: self.filter.clone(),
558 order: self.order.clone(),
559 limit: self.limit,
560 nested: self.nested.clone(),
561 _marker: PhantomData,
562 }
563 }
564}
565
566impl<'db, M, C, J, Key, CKey> IncludeMany<'db, M, C, J, Key, CKey, ()>
567where
568 M: Model,
569 C: Model,
570 J: Model,
571{
572 #[allow(clippy::too_many_arguments)]
574 pub const fn new(
575 get: fn(&M) -> Key,
576 set: fn(&mut M, Related<Vec<C>>),
577 join_owner_get: fn(&J) -> Key,
578 join_target_get: fn(&J) -> CKey,
579 child_key_get: fn(&C) -> CKey,
580 join_owner_col: Column<J, Key>,
581 join_target_col: Column<J, CKey>,
582 target_pk: Column<C, CKey>,
583 ) -> Self {
584 Self {
585 get,
586 set,
587 join_owner_get,
588 join_target_get,
589 child_key_get,
590 join_owner_col,
591 join_target_col,
592 target_pk,
593 filter: Filter::new(crate::filter::FilterNode::And(Vec::new())),
594 order: Vec::new(),
595 limit: None,
596 nested: (),
597 _marker: PhantomData,
598 }
599 }
600}
601
602impl<'db, M, C, J, Key, CKey, NI> IncludeMany<'db, M, C, J, Key, CKey, NI>
603where
604 M: Model,
605 C: Model,
606 J: Model,
607{
608 pub fn filter(mut self, f: Filter<C>) -> Self {
610 self.filter = self.filter.and(f);
611 self
612 }
613
614 pub fn order_by(mut self, o: OrderBy<C>) -> Self {
616 self.order.push(o);
617 self
618 }
619
620 pub fn take(mut self, n: u64) -> Self {
622 self.limit = Some(n);
623 self
624 }
625
626 pub fn include<Next: IncludeSet<C>>(
628 self,
629 include: Next,
630 ) -> IncludeMany<'db, M, C, J, Key, CKey, Next> {
631 IncludeMany {
632 get: self.get,
633 set: self.set,
634 join_owner_get: self.join_owner_get,
635 join_target_get: self.join_target_get,
636 child_key_get: self.child_key_get,
637 join_owner_col: self.join_owner_col,
638 join_target_col: self.join_target_col,
639 target_pk: self.target_pk,
640 filter: self.filter,
641 order: self.order,
642 limit: self.limit,
643 nested: include,
644 _marker: PhantomData,
645 }
646 }
647}
648
649impl<'db, M, C, J, Key, CKey, NI> IncludeSet<M> for IncludeMany<'db, M, C, J, Key, CKey, NI>
650where
651 M: Model + Send + Unpin,
652 C: Model + Clone + Send + Unpin,
653 J: Model + Send + Unpin,
654 Key: Encodable + Eq + Hash + Clone + Send + Sync + 'static,
655 CKey: Encodable + Eq + Hash + Clone + Send + Sync + 'static,
656 NI: IncludeSet<C> + Sync,
657{
658 fn load<'a>(
659 &'a self,
660 exec: &'a dyn Executor,
661 parents: &'a mut [M],
662 _full_table: bool,
663 ) -> BoxFuture<'a, Result<(), Error>> {
664 Box::pin(async move {
665 if parents.is_empty() {
666 return Ok(());
667 }
668
669 let keys: Vec<Key> = parents.iter().map(self.get).collect();
670 let deduped = dedup(&keys);
671 let caps = exec.dialect().capabilities();
672 let chunk_size = (caps.max_query_params as usize).saturating_sub(10).max(1);
673
674 let mut join_rows: Vec<J> = Vec::new();
676 for chunk in deduped.chunks(chunk_size) {
677 let values: Vec<Key> = chunk.iter().copied().cloned().collect();
678 let q = SelectQuery::<J>::new(exec)
679 .filter(self.join_owner_col.in_set(values))
680 .order_by(self.join_owner_col.asc())
681 .order_by(self.join_target_col.asc());
682 join_rows.extend(q.fetch_all().await?);
683 }
684
685 if join_rows.is_empty() {
686 for parent in parents.iter_mut() {
687 (self.set)(parent, Related::Loaded(Vec::new()));
688 }
689 return Ok(());
690 }
691
692 let child_keys: Vec<CKey> = join_rows
694 .iter()
695 .map(|j| (self.join_target_get)(j))
696 .collect();
697 let child_keys = dedup(&child_keys).into_iter().cloned().collect::<Vec<_>>();
698
699 let mut children: Vec<C> = Vec::new();
702 for chunk in child_keys.chunks(chunk_size) {
703 let values: Vec<CKey> = chunk.to_vec();
704 let mut q = SelectQuery::<C>::new(exec).filter(self.target_pk.in_set(values));
705 if self.filter.node != crate::filter::FilterNode::And(Vec::new()) {
706 q = q.filter(self.filter.clone());
707 }
708 for o in &self.order {
709 q = q.order_by(o.clone());
710 }
711 children.extend(q.fetch_all().await?);
712 }
713
714 self.nested.load(exec, &mut children, false).await?;
716
717 let mut parent_index: HashMap<Key, Vec<usize>> = HashMap::with_capacity(parents.len());
719 for (i, parent) in parents.iter().enumerate() {
720 parent_index.entry((self.get)(parent)).or_default().push(i);
721 }
722
723 let mut child_to_parents: HashMap<CKey, Vec<usize>> =
725 HashMap::with_capacity(join_rows.len());
726 for j in &join_rows {
727 let owner = (self.join_owner_get)(j);
728 if let Some(indices) = parent_index.get(&owner) {
729 let target = (self.join_target_get)(j);
730 child_to_parents
731 .entry(target)
732 .or_default()
733 .extend(indices.iter().copied());
734 }
735 }
736
737 let mut buckets: Vec<Vec<C>> = std::iter::repeat_with(Vec::new)
740 .take(parents.len())
741 .collect();
742 for child in children {
743 let target_key = (self.child_key_get)(&child);
744 if let Some(parents) = child_to_parents.get(&target_key) {
745 for &idx in parents {
746 buckets[idx].push(child.clone());
747 }
748 }
749 }
750
751 for (parent, mut bucket) in parents.iter_mut().zip(buckets) {
753 if let Some(n) = self.limit {
754 let n = n as usize;
755 if bucket.len() > n {
756 bucket.truncate(n);
757 }
758 }
759 (self.set)(parent, Related::Loaded(bucket));
760 }
761
762 Ok(())
763 })
764 }
765}
766
767impl<'db, M, C, Key, NI> IncludeSet<M> for IncludeOne<'db, M, C, Key, NI>
768where
769 M: Model + Send + Unpin,
770 C: Model + Clone + Send + Unpin,
771 Key: Encodable + Eq + Hash + Clone + Send + Sync + 'static,
772 NI: IncludeSet<C> + Sync,
773{
774 fn load<'a>(
775 &'a self,
776 exec: &'a dyn Executor,
777 parents: &'a mut [M],
778 full_table: bool,
779 ) -> BoxFuture<'a, Result<(), Error>> {
780 Box::pin(async move {
781 if parents.is_empty() {
782 return Ok(());
783 }
784
785 let keys: Vec<Key> = parents.iter().map(self.get).collect();
786 let mut children = fetch_children(
787 exec,
788 self.child_key,
789 &self.filter,
790 &self.order,
791 self.limit,
792 &keys,
793 full_table,
794 )
795 .await?;
796
797 let child_full_table = full_table
798 && self.filter.node == crate::filter::FilterNode::And(Vec::new())
799 && self.order.is_empty()
800 && self.limit.is_none();
801 self.nested
802 .load(exec, &mut children, child_full_table)
803 .await?;
804
805 let mut map: HashMap<Key, C> = HashMap::with_capacity(parents.len());
806 for child in children {
807 let key = (self.child_key_get)(&child);
808 if let std::collections::hash_map::Entry::Vacant(e) = map.entry(key) {
809 e.insert(child);
810 }
811 }
812
813 for parent in parents.iter_mut() {
814 let key = (self.get)(parent);
815 let related = Related::Loaded(map.get(&key).cloned());
816 (self.set)(parent, related);
817 }
818
819 Ok(())
820 })
821 }
822}