1use crate::{
2 join_tbl_on_condition, unpack_table_ref, ColumnTrait, EntityTrait, IdenStatic, Iterable,
3 Linked, QuerySelect, Related, Select, SelectA, SelectB, SelectThree, SelectTwo, SelectTwoMany,
4};
5pub use sea_query::JoinType;
6use sea_query::{Alias, Condition, Expr, IntoIden, SeaRc, SelectExpr};
7
8impl<E> Select<E>
9where
10 E: EntityTrait,
11{
12 pub fn left_join<R>(self, _: R) -> Self
14 where
15 R: EntityTrait,
16 E: Related<R>,
17 {
18 self.join_join(JoinType::LeftJoin, E::to(), E::via())
19 }
20
21 pub fn right_join<R>(self, _: R) -> Self
23 where
24 R: EntityTrait,
25 E: Related<R>,
26 {
27 self.join_join(JoinType::RightJoin, E::to(), E::via())
28 }
29
30 pub fn inner_join<R>(self, _: R) -> Self
32 where
33 R: EntityTrait,
34 E: Related<R>,
35 {
36 self.join_join(JoinType::InnerJoin, E::to(), E::via())
37 }
38
39 pub fn reverse_join<R>(self, _: R) -> Self
41 where
42 R: EntityTrait + Related<E>,
43 {
44 self.join_rev(JoinType::InnerJoin, R::to())
45 }
46
47 pub fn find_also_related<R>(self, r: R) -> SelectTwo<E, R>
49 where
50 R: EntityTrait,
51 E: Related<R>,
52 {
53 self.left_join(r).select_also(r)
54 }
55
56 pub fn find_with_related<R>(self, r: R) -> SelectTwoMany<E, R>
58 where
59 R: EntityTrait,
60 E: Related<R>,
61 {
62 self.left_join(r).select_with(r)
63 }
64
65 pub fn find_also_linked<L, T>(self, l: L) -> SelectTwo<E, T>
67 where
68 L: Linked<FromEntity = E, ToEntity = T>,
69 T: EntityTrait,
70 {
71 let mut slf = self;
72 for (i, mut rel) in l.link().into_iter().enumerate() {
73 let to_tbl = Alias::new(format!("r{i}")).into_iden();
74 let from_tbl = if i > 0 {
75 Alias::new(format!("r{}", i - 1)).into_iden()
76 } else {
77 unpack_table_ref(&rel.from_tbl)
78 };
79 let table_ref = rel.to_tbl;
80
81 let mut condition = Condition::all().add(join_tbl_on_condition(
82 SeaRc::clone(&from_tbl),
83 SeaRc::clone(&to_tbl),
84 rel.from_col,
85 rel.to_col,
86 ));
87 if let Some(f) = rel.on_condition.take() {
88 condition = condition.add(f(SeaRc::clone(&from_tbl), SeaRc::clone(&to_tbl)));
89 }
90
91 slf.query()
92 .join_as(JoinType::LeftJoin, table_ref, to_tbl, condition);
93 }
94 slf = slf.apply_alias(SelectA.as_str());
95 let mut select_two = SelectTwo::new_without_prepare(slf.query);
96 for col in <T::Column as Iterable>::iter() {
97 let alias = format!("{}{}", SelectB.as_str(), col.as_str());
98 let expr = Expr::col((
99 Alias::new(format!("r{}", l.link().len() - 1)).into_iden(),
100 col.into_iden(),
101 ));
102 select_two.query().expr(SelectExpr {
103 expr: col.select_as(expr),
104 alias: Some(SeaRc::new(Alias::new(alias))),
105 window: None,
106 });
107 }
108 select_two
109 }
110
111 pub fn find_with_linked<L, T>(self, l: L) -> SelectTwoMany<E, T>
113 where
114 L: Linked<FromEntity = E, ToEntity = T>,
115 T: EntityTrait,
116 {
117 let mut slf = self;
118 for (i, mut rel) in l.link().into_iter().enumerate() {
119 let to_tbl = Alias::new(format!("r{i}")).into_iden();
120 let from_tbl = if i > 0 {
121 Alias::new(format!("r{}", i - 1)).into_iden()
122 } else {
123 unpack_table_ref(&rel.from_tbl)
124 };
125 let table_ref = rel.to_tbl;
126
127 let mut condition = Condition::all().add(join_tbl_on_condition(
128 SeaRc::clone(&from_tbl),
129 SeaRc::clone(&to_tbl),
130 rel.from_col,
131 rel.to_col,
132 ));
133 if let Some(f) = rel.on_condition.take() {
134 condition = condition.add(f(SeaRc::clone(&from_tbl), SeaRc::clone(&to_tbl)));
135 }
136
137 slf.query()
138 .join_as(JoinType::LeftJoin, table_ref, to_tbl, condition);
139 }
140 slf = slf.apply_alias(SelectA.as_str());
141 let mut select_two_many = SelectTwoMany::new_without_prepare(slf.query);
142 for col in <T::Column as Iterable>::iter() {
143 let alias = format!("{}{}", SelectB.as_str(), col.as_str());
144 let expr = Expr::col((
145 Alias::new(format!("r{}", l.link().len() - 1)).into_iden(),
146 col.into_iden(),
147 ));
148 select_two_many.query().expr(SelectExpr {
149 expr: col.select_as(expr),
150 alias: Some(SeaRc::new(Alias::new(alias))),
151 window: None,
152 });
153 }
154 select_two_many
155 }
156}
157
158impl<E, F> SelectTwo<E, F>
159where
160 E: EntityTrait,
161 F: EntityTrait,
162{
163 pub fn find_also_related<R>(self, r: R) -> SelectThree<E, F, R>
165 where
166 R: EntityTrait,
167 E: Related<R>,
168 {
169 self.join_join(JoinType::LeftJoin, E::to(), E::via())
170 .select_also(r)
171 }
172
173 pub fn and_also_related<R>(self, r: R) -> SelectThree<E, F, R>
175 where
176 R: EntityTrait,
177 F: Related<R>,
178 {
179 self.join_join(JoinType::LeftJoin, F::to(), F::via())
180 .select_also(r)
181 }
182}
183
184#[cfg(test)]
185mod tests {
186 use crate::tests_cfg::{cake, cake_filling, cake_filling_price, entity_linked, filling, fruit};
187 use crate::{
188 ColumnTrait, DbBackend, EntityTrait, ModelTrait, QueryFilter, QuerySelect, QueryTrait,
189 RelationTrait,
190 };
191 use pretty_assertions::assert_eq;
192 use sea_query::{Alias, ConditionType, Expr, IntoCondition, JoinType};
193
194 #[test]
195 fn join_1() {
196 assert_eq!(
197 cake::Entity::find()
198 .left_join(fruit::Entity)
199 .build(DbBackend::MySql)
200 .to_string(),
201 [
202 "SELECT `cake`.`id`, `cake`.`name` FROM `cake`",
203 "LEFT JOIN `fruit` ON `cake`.`id` = `fruit`.`cake_id`",
204 ]
205 .join(" ")
206 );
207 }
208
209 #[test]
210 fn join_2() {
211 assert_eq!(
212 cake::Entity::find()
213 .inner_join(fruit::Entity)
214 .filter(fruit::Column::Name.contains("cherry"))
215 .build(DbBackend::MySql)
216 .to_string(),
217 [
218 "SELECT `cake`.`id`, `cake`.`name` FROM `cake`",
219 "INNER JOIN `fruit` ON `cake`.`id` = `fruit`.`cake_id`",
220 "WHERE `fruit`.`name` LIKE \'%cherry%\'"
221 ]
222 .join(" ")
223 );
224 }
225
226 #[test]
227 fn join_3() {
228 assert_eq!(
229 fruit::Entity::find()
230 .reverse_join(cake::Entity)
231 .build(DbBackend::MySql)
232 .to_string(),
233 [
234 "SELECT `fruit`.`id`, `fruit`.`name`, `fruit`.`cake_id` FROM `fruit`",
235 "INNER JOIN `cake` ON `cake`.`id` = `fruit`.`cake_id`",
236 ]
237 .join(" ")
238 );
239 }
240
241 #[test]
242 fn join_4() {
243 use crate::{Related, Select};
244
245 let find_fruit: Select<fruit::Entity> = cake::Entity::find_related();
246 assert_eq!(
247 find_fruit
248 .filter(cake::Column::Id.eq(11))
249 .build(DbBackend::MySql)
250 .to_string(),
251 [
252 "SELECT `fruit`.`id`, `fruit`.`name`, `fruit`.`cake_id` FROM `fruit`",
253 "INNER JOIN `cake` ON `cake`.`id` = `fruit`.`cake_id`",
254 "WHERE `cake`.`id` = 11",
255 ]
256 .join(" ")
257 );
258 }
259
260 #[test]
261 fn join_5() {
262 let cake_model = cake::Model {
263 id: 12,
264 name: "".to_owned(),
265 };
266
267 assert_eq!(
268 cake_model
269 .find_related(fruit::Entity)
270 .build(DbBackend::MySql)
271 .to_string(),
272 [
273 "SELECT `fruit`.`id`, `fruit`.`name`, `fruit`.`cake_id` FROM `fruit`",
274 "INNER JOIN `cake` ON `cake`.`id` = `fruit`.`cake_id`",
275 "WHERE `cake`.`id` = 12",
276 ]
277 .join(" ")
278 );
279 }
280
281 #[test]
282 fn join_6() {
283 assert_eq!(
284 cake::Entity::find()
285 .left_join(filling::Entity)
286 .build(DbBackend::MySql)
287 .to_string(),
288 [
289 "SELECT `cake`.`id`, `cake`.`name` FROM `cake`",
290 "LEFT JOIN `cake_filling` ON `cake`.`id` = `cake_filling`.`cake_id`",
291 "LEFT JOIN `filling` ON `cake_filling`.`filling_id` = `filling`.`id`",
292 ]
293 .join(" ")
294 );
295 }
296
297 #[test]
298 fn join_7() {
299 use crate::{Related, Select};
300
301 let find_filling: Select<filling::Entity> = cake::Entity::find_related();
302 assert_eq!(
303 find_filling.build(DbBackend::MySql).to_string(),
304 [
305 "SELECT `filling`.`id`, `filling`.`name`, `filling`.`vendor_id` FROM `filling`",
306 "INNER JOIN `cake_filling` ON `cake_filling`.`filling_id` = `filling`.`id`",
307 "INNER JOIN `cake` ON `cake`.`id` = `cake_filling`.`cake_id`",
308 ]
309 .join(" ")
310 );
311 }
312
313 #[test]
314 fn join_8() {
315 use crate::{Related, Select};
316
317 let find_cake_filling_price: Select<cake_filling_price::Entity> =
318 cake_filling::Entity::find_related();
319 assert_eq!(
320 find_cake_filling_price.build(DbBackend::Postgres).to_string(),
321 [
322 r#"SELECT "cake_filling_price"."cake_id", "cake_filling_price"."filling_id", "cake_filling_price"."price""#,
323 r#"FROM "public"."cake_filling_price""#,
324 r#"INNER JOIN "cake_filling" ON"#,
325 r#""cake_filling"."cake_id" = "cake_filling_price"."cake_id" AND"#,
326 r#""cake_filling"."filling_id" = "cake_filling_price"."filling_id""#,
327 ]
328 .join(" ")
329 );
330 }
331
332 #[test]
333 fn join_9() {
334 use crate::{Related, Select};
335
336 let find_cake_filling: Select<cake_filling::Entity> =
337 cake_filling_price::Entity::find_related();
338 assert_eq!(
339 find_cake_filling.build(DbBackend::Postgres).to_string(),
340 [
341 r#"SELECT "cake_filling"."cake_id", "cake_filling"."filling_id""#,
342 r#"FROM "cake_filling""#,
343 r#"INNER JOIN "public"."cake_filling_price" ON"#,
344 r#""cake_filling_price"."cake_id" = "cake_filling"."cake_id" AND"#,
345 r#""cake_filling_price"."filling_id" = "cake_filling"."filling_id""#,
346 ]
347 .join(" ")
348 );
349 }
350
351 #[test]
352 fn join_10() {
353 let cake_model = cake::Model {
354 id: 12,
355 name: "".to_owned(),
356 };
357
358 assert_eq!(
359 cake_model
360 .find_linked(entity_linked::CakeToFilling)
361 .build(DbBackend::MySql)
362 .to_string(),
363 [
364 r#"SELECT `filling`.`id`, `filling`.`name`, `filling`.`vendor_id`"#,
365 r#"FROM `filling`"#,
366 r#"INNER JOIN `cake_filling` AS `r0` ON `r0`.`filling_id` = `filling`.`id`"#,
367 r#"INNER JOIN `cake` AS `r1` ON `r1`.`id` = `r0`.`cake_id`"#,
368 r#"WHERE `r1`.`id` = 12"#,
369 ]
370 .join(" ")
371 );
372 }
373
374 #[test]
375 fn join_11() {
376 let cake_model = cake::Model {
377 id: 18,
378 name: "".to_owned(),
379 };
380
381 assert_eq!(
382 cake_model
383 .find_linked(entity_linked::CakeToFillingVendor)
384 .build(DbBackend::MySql)
385 .to_string(),
386 [
387 r#"SELECT `vendor`.`id`, `vendor`.`name`"#,
388 r#"FROM `vendor`"#,
389 r#"INNER JOIN `filling` AS `r0` ON `r0`.`vendor_id` = `vendor`.`id`"#,
390 r#"INNER JOIN `cake_filling` AS `r1` ON `r1`.`filling_id` = `r0`.`id`"#,
391 r#"INNER JOIN `cake` AS `r2` ON `r2`.`id` = `r1`.`cake_id`"#,
392 r#"WHERE `r2`.`id` = 18"#,
393 ]
394 .join(" ")
395 );
396 }
397
398 #[test]
399 fn join_12() {
400 assert_eq!(
401 cake::Entity::find()
402 .find_also_linked(entity_linked::CakeToFilling)
403 .build(DbBackend::MySql)
404 .to_string(),
405 [
406 r#"SELECT `cake`.`id` AS `A_id`, `cake`.`name` AS `A_name`,"#,
407 r#"`r1`.`id` AS `B_id`, `r1`.`name` AS `B_name`, `r1`.`vendor_id` AS `B_vendor_id`"#,
408 r#"FROM `cake`"#,
409 r#"LEFT JOIN `cake_filling` AS `r0` ON `cake`.`id` = `r0`.`cake_id`"#,
410 r#"LEFT JOIN `filling` AS `r1` ON `r0`.`filling_id` = `r1`.`id`"#,
411 ]
412 .join(" ")
413 );
414 }
415
416 #[test]
417 fn join_13() {
418 assert_eq!(
419 cake::Entity::find()
420 .find_also_linked(entity_linked::CakeToFillingVendor)
421 .build(DbBackend::MySql)
422 .to_string(),
423 [
424 r#"SELECT `cake`.`id` AS `A_id`, `cake`.`name` AS `A_name`,"#,
425 r#"`r2`.`id` AS `B_id`, `r2`.`name` AS `B_name`"#,
426 r#"FROM `cake`"#,
427 r#"LEFT JOIN `cake_filling` AS `r0` ON `cake`.`id` = `r0`.`cake_id`"#,
428 r#"LEFT JOIN `filling` AS `r1` ON `r0`.`filling_id` = `r1`.`id`"#,
429 r#"LEFT JOIN `vendor` AS `r2` ON `r1`.`vendor_id` = `r2`.`id`"#,
430 ]
431 .join(" ")
432 );
433 }
434
435 #[test]
436 fn join_14() {
437 assert_eq!(
438 cake::Entity::find()
439 .join(JoinType::LeftJoin, cake::Relation::TropicalFruit.def())
440 .build(DbBackend::MySql)
441 .to_string(),
442 [
443 "SELECT `cake`.`id`, `cake`.`name` FROM `cake`",
444 "LEFT JOIN `fruit` ON `cake`.`id` = `fruit`.`cake_id` AND `fruit`.`name` LIKE '%tropical%'",
445 ]
446 .join(" ")
447 );
448 }
449
450 #[test]
451 fn join_15() {
452 let cake_model = cake::Model {
453 id: 18,
454 name: "".to_owned(),
455 };
456
457 assert_eq!(
458 cake_model
459 .find_linked(entity_linked::CheeseCakeToFillingVendor)
460 .build(DbBackend::MySql)
461 .to_string(),
462 [
463 r#"SELECT `vendor`.`id`, `vendor`.`name`"#,
464 r#"FROM `vendor`"#,
465 r#"INNER JOIN `filling` AS `r0` ON `r0`.`vendor_id` = `vendor`.`id`"#,
466 r#"INNER JOIN `cake_filling` AS `r1` ON `r1`.`filling_id` = `r0`.`id`"#,
467 r#"INNER JOIN `cake` AS `r2` ON `r2`.`id` = `r1`.`cake_id` AND `r2`.`name` LIKE '%cheese%'"#,
468 r#"WHERE `r2`.`id` = 18"#,
469 ]
470 .join(" ")
471 );
472 }
473
474 #[test]
475 fn join_16() {
476 let cake_model = cake::Model {
477 id: 18,
478 name: "".to_owned(),
479 };
480 assert_eq!(
481 cake_model
482 .find_linked(entity_linked::JoinWithoutReverse)
483 .build(DbBackend::MySql)
484 .to_string(),
485 [
486 r#"SELECT `vendor`.`id`, `vendor`.`name`"#,
487 r#"FROM `vendor`"#,
488 r#"INNER JOIN `filling` AS `r0` ON `r0`.`vendor_id` = `vendor`.`id`"#,
489 r#"INNER JOIN `cake_filling` AS `r1` ON `r1`.`filling_id` = `r0`.`id`"#,
490 r#"INNER JOIN `cake_filling` AS `r2` ON `r2`.`cake_id` = `r1`.`id` AND `r2`.`name` LIKE '%cheese%'"#,
491 r#"WHERE `r2`.`id` = 18"#,
492 ]
493 .join(" ")
494 );
495 }
496
497 #[test]
498 fn join_17() {
499 assert_eq!(
500 cake::Entity::find()
501 .find_also_linked(entity_linked::CheeseCakeToFillingVendor)
502 .build(DbBackend::MySql)
503 .to_string(),
504 [
505 r#"SELECT `cake`.`id` AS `A_id`, `cake`.`name` AS `A_name`,"#,
506 r#"`r2`.`id` AS `B_id`, `r2`.`name` AS `B_name`"#,
507 r#"FROM `cake`"#,
508 r#"LEFT JOIN `cake_filling` AS `r0` ON `cake`.`id` = `r0`.`cake_id` AND `cake`.`name` LIKE '%cheese%'"#,
509 r#"LEFT JOIN `filling` AS `r1` ON `r0`.`filling_id` = `r1`.`id`"#,
510 r#"LEFT JOIN `vendor` AS `r2` ON `r1`.`vendor_id` = `r2`.`id`"#,
511 ]
512 .join(" ")
513 );
514 }
515
516 #[test]
517 fn join_18() {
518 assert_eq!(
519 cake::Entity::find()
520 .find_also_linked(entity_linked::JoinWithoutReverse)
521 .build(DbBackend::MySql)
522 .to_string(),
523 [
524 r#"SELECT `cake`.`id` AS `A_id`, `cake`.`name` AS `A_name`,"#,
525 r#"`r2`.`id` AS `B_id`, `r2`.`name` AS `B_name`"#,
526 r#"FROM `cake`"#,
527 r#"LEFT JOIN `cake` AS `r0` ON `cake_filling`.`cake_id` = `r0`.`id` AND `cake_filling`.`name` LIKE '%cheese%'"#,
528 r#"LEFT JOIN `filling` AS `r1` ON `r0`.`filling_id` = `r1`.`id`"#,
529 r#"LEFT JOIN `vendor` AS `r2` ON `r1`.`vendor_id` = `r2`.`id`"#,
530 ]
531 .join(" ")
532 );
533 }
534
535 #[test]
536 fn join_19() {
537 assert_eq!(
538 cake::Entity::find()
539 .join(JoinType::LeftJoin, cake::Relation::TropicalFruit.def())
540 .join(
541 JoinType::LeftJoin,
542 cake_filling::Relation::Cake
543 .def()
544 .rev()
545 .on_condition(|_left, right| {
546 Expr::col((right, cake_filling::Column::CakeId))
547 .gt(10)
548 .into_condition()
549 })
550 )
551 .join(
552 JoinType::LeftJoin,
553 cake_filling::Relation::Filling
554 .def()
555 .on_condition(|_left, right| {
556 Expr::col((right, filling::Column::Name))
557 .like("%lemon%")
558 .into_condition()
559 })
560 )
561 .join(JoinType::LeftJoin, filling::Relation::Vendor.def())
562 .build(DbBackend::MySql)
563 .to_string(),
564 [
565 "SELECT `cake`.`id`, `cake`.`name` FROM `cake`",
566 "LEFT JOIN `fruit` ON `cake`.`id` = `fruit`.`cake_id` AND `fruit`.`name` LIKE '%tropical%'",
567 "LEFT JOIN `cake_filling` ON `cake`.`id` = `cake_filling`.`cake_id` AND `cake_filling`.`cake_id` > 10",
568 "LEFT JOIN `filling` ON `cake_filling`.`filling_id` = `filling`.`id` AND `filling`.`name` LIKE '%lemon%'",
569 "LEFT JOIN `vendor` ON `filling`.`vendor_id` = `vendor`.`id`",
570 ]
571 .join(" ")
572 );
573 }
574
575 #[test]
576 fn join_20() {
577 assert_eq!(
578 cake::Entity::find()
579 .column_as(
580 Expr::col((Alias::new("fruit_alias"), fruit::Column::Name)),
581 "fruit_name"
582 )
583 .join_as(
584 JoinType::LeftJoin,
585 cake::Relation::Fruit
586 .def()
587 .on_condition(|_left, right| {
588 Expr::col((right, fruit::Column::Name))
589 .like("%tropical%")
590 .into_condition()
591 }),
592 Alias::new("fruit_alias")
593 )
594 .build(DbBackend::MySql)
595 .to_string(),
596 [
597 "SELECT `cake`.`id`, `cake`.`name`, `fruit_alias`.`name` AS `fruit_name` FROM `cake`",
598 "LEFT JOIN `fruit` AS `fruit_alias` ON `cake`.`id` = `fruit_alias`.`cake_id` AND `fruit_alias`.`name` LIKE '%tropical%'",
599 ]
600 .join(" ")
601 );
602 }
603
604 #[test]
605 fn join_21() {
606 assert_eq!(
607 cake::Entity::find()
608 .column_as(
609 Expr::col((Alias::new("cake_filling_alias"), cake_filling::Column::CakeId)),
610 "cake_filling_cake_id"
611 )
612 .join(JoinType::LeftJoin, cake::Relation::TropicalFruit.def())
613 .join_as_rev(
614 JoinType::LeftJoin,
615 cake_filling::Relation::Cake
616 .def()
617 .on_condition(|left, _right| {
618 Expr::col((left, cake_filling::Column::CakeId))
619 .gt(10)
620 .into_condition()
621 }),
622 Alias::new("cake_filling_alias")
623 )
624 .build(DbBackend::MySql)
625 .to_string(),
626 [
627 "SELECT `cake`.`id`, `cake`.`name`, `cake_filling_alias`.`cake_id` AS `cake_filling_cake_id` FROM `cake`",
628 "LEFT JOIN `fruit` ON `cake`.`id` = `fruit`.`cake_id` AND `fruit`.`name` LIKE '%tropical%'",
629 "LEFT JOIN `cake_filling` AS `cake_filling_alias` ON `cake_filling_alias`.`cake_id` = `cake`.`id` AND `cake_filling_alias`.`cake_id` > 10",
630 ]
631 .join(" ")
632 );
633 }
634
635 #[test]
636 fn join_22() {
637 assert_eq!(
638 cake::Entity::find()
639 .column_as(
640 Expr::col((Alias::new("cake_filling_alias"), cake_filling::Column::CakeId)),
641 "cake_filling_cake_id"
642 )
643 .join(JoinType::LeftJoin, cake::Relation::OrTropicalFruit.def())
644 .join_as_rev(
645 JoinType::LeftJoin,
646 cake_filling::Relation::Cake
647 .def()
648 .condition_type(ConditionType::Any)
649 .on_condition(|left, _right| {
650 Expr::col((left, cake_filling::Column::CakeId))
651 .gt(10)
652 .into_condition()
653 }),
654 Alias::new("cake_filling_alias")
655 )
656 .build(DbBackend::MySql)
657 .to_string(),
658 [
659 "SELECT `cake`.`id`, `cake`.`name`, `cake_filling_alias`.`cake_id` AS `cake_filling_cake_id` FROM `cake`",
660 "LEFT JOIN `fruit` ON `cake`.`id` = `fruit`.`cake_id` OR `fruit`.`name` LIKE '%tropical%'",
661 "LEFT JOIN `cake_filling` AS `cake_filling_alias` ON `cake_filling_alias`.`cake_id` = `cake`.`id` OR `cake_filling_alias`.`cake_id` > 10",
662 ]
663 .join(" ")
664 );
665 }
666}