1use crate::dsl::{AsExpr, AsExprOf, SqlTypeOf};
2use crate::expression::grouped::Grouped;
3use crate::expression::Expression;
4use crate::pg::expression::expression_methods::private::{JsonIndex, JsonRemoveIndex};
5use crate::pg::types::sql_types::Array;
6use crate::sql_types::{Inet, Integer, VarChar};
7
8#[cfg(feature = "postgres_backend")]
10pub type ILike<Lhs, Rhs> = Grouped<super::operators::ILike<Lhs, AsExprOf<Rhs, VarChar>>>;
11#[doc(hidden)] pub type Ilike<Lhs, Rhs> = ILike<Lhs, Rhs>;
13
14#[cfg(feature = "postgres_backend")]
16pub type NotILike<Lhs, Rhs> = Grouped<super::operators::NotILike<Lhs, AsExprOf<Rhs, VarChar>>>;
17#[doc(hidden)] pub type NotIlike<Lhs, Rhs> = NotILike<Lhs, Rhs>;
19
20#[cfg(feature = "postgres_backend")]
22pub type SimilarTo<Lhs, Rhs> = Grouped<super::operators::SimilarTo<Lhs, AsExprOf<Rhs, VarChar>>>;
23
24#[cfg(feature = "postgres_backend")]
26pub type NotSimilarTo<Lhs, Rhs> =
27 Grouped<super::operators::NotSimilarTo<Lhs, AsExprOf<Rhs, VarChar>>>;
28
29#[cfg(feature = "postgres_backend")]
31pub type IsNotDistinctFrom<Lhs, Rhs> =
32 Grouped<super::operators::IsNotDistinctFrom<Lhs, AsExpr<Rhs, Lhs>>>;
33
34#[cfg(feature = "postgres_backend")]
36pub type IsDistinctFrom<Lhs, Rhs> =
37 Grouped<super::operators::IsDistinctFrom<Lhs, AsExpr<Rhs, Lhs>>>;
38
39#[cfg(feature = "postgres_backend")]
42pub type OverlapsWith<Lhs, Rhs> = Grouped<super::operators::OverlapsWith<Lhs, AsExpr<Rhs, Lhs>>>;
43
44#[cfg(feature = "postgres_backend")]
47pub type Contains<Lhs, Rhs> = Grouped<super::operators::Contains<Lhs, AsExpr<Rhs, Lhs>>>;
48
49#[doc(hidden)]
50#[deprecated(note = "Use `Contains` instead")]
51pub type ArrayContains<Lhs, Rhs> = Contains<Lhs, Rhs>;
52
53#[cfg(feature = "postgres_backend")]
56pub type RangeContains<Lhs, Rhs> = Grouped<
57 super::operators::Contains<
58 Lhs,
59 AsExprOf<Rhs, <SqlTypeOf<Lhs> as super::expression_methods::RangeOrMultirange>::Inner>,
60 >,
61>;
62
63#[cfg(feature = "postgres_backend")]
66pub type RangeExtendsRightTo<Lhs, Rhs> =
67 Grouped<super::operators::ExtendsRightTo<Lhs, AsExpr<Rhs, Lhs>>>;
68
69#[cfg(feature = "postgres_backend")]
72pub type RangeExtendsLeftTo<Lhs, Rhs> =
73 Grouped<super::operators::ExtendsLeftTo<Lhs, AsExpr<Rhs, Lhs>>>;
74
75#[cfg(feature = "postgres_backend")]
78pub type ContainsRange<Lhs, Rhs> = Contains<Lhs, Rhs>;
79
80#[cfg(feature = "postgres_backend")]
83pub type IsContainedBy<Lhs, Rhs> = Grouped<super::operators::IsContainedBy<Lhs, AsExpr<Rhs, Lhs>>>;
84
85#[cfg(feature = "postgres_backend")]
87pub type IsContainedByRange<Lhs, Rhs> = Grouped<
88 super::operators::IsContainedBy<Lhs, AsExprOf<Rhs, diesel::sql_types::Range<SqlTypeOf<Lhs>>>>,
89>;
90
91#[cfg(feature = "postgres_backend")]
93pub type LesserThanRange<Lhs, Rhs> =
94 Grouped<super::operators::IsContainedByNet<Lhs, AsExpr<Rhs, Lhs>>>;
95
96#[doc(hidden)] pub type LesserThan<Lhs, Rhs> = LesserThanRange<Lhs, Rhs>;
98
99#[cfg(feature = "postgres_backend")]
101pub type GreaterThanRange<Lhs, Rhs> = Grouped<super::operators::ContainsNet<Lhs, AsExpr<Rhs, Lhs>>>;
102
103#[doc(hidden)] pub type GreaterThan<Lhs, Rhs> = GreaterThanRange<Lhs, Rhs>;
105
106#[cfg(feature = "postgres_backend")]
108pub type UnionRange<Lhs, Rhs> = Grouped<super::operators::UnionsRange<Lhs, AsExpr<Rhs, Lhs>>>;
109
110#[cfg(feature = "postgres_backend")]
112pub type Difference<Lhs, Rhs> = Grouped<super::operators::DifferenceRange<Lhs, AsExpr<Rhs, Lhs>>>;
113
114#[doc(hidden)] pub type DifferenceRange<Lhs, Rhs> = Difference<Lhs, Rhs>;
116
117#[cfg(feature = "postgres_backend")]
119pub type RangeAdjacent<Lhs, Rhs> = Grouped<super::operators::RangeAdjacent<Lhs, AsExpr<Rhs, Lhs>>>;
120
121#[cfg(feature = "postgres_backend")]
123pub type Intersection<Lhs, Rhs> =
124 Grouped<super::operators::IntersectionRange<Lhs, AsExpr<Rhs, Lhs>>>;
125
126#[doc(hidden)] pub type IntersectionRange<Lhs, Rhs> = Intersection<Lhs, Rhs>;
128
129#[cfg(feature = "postgres_backend")]
131pub type NullsFirst<T> = super::operators::NullsFirst<T>;
132
133#[cfg(feature = "postgres_backend")]
135pub type IsJson<T> = super::operators::IsJson<T>;
136
137#[cfg(feature = "postgres_backend")]
139pub type IsNotJson<T> = super::operators::IsNotJson<T>;
140
141#[cfg(feature = "postgres_backend")]
143pub type IsJsonObject<T> = super::operators::IsJsonObject<T>;
144
145#[cfg(feature = "postgres_backend")]
147pub type IsNotJsonObject<T> = super::operators::IsNotJsonObject<T>;
148
149#[cfg(feature = "postgres_backend")]
151pub type IsJsonArray<T> = super::operators::IsJsonArray<T>;
152
153#[cfg(feature = "postgres_backend")]
155pub type IsNotJsonArray<T> = super::operators::IsNotJsonArray<T>;
156
157#[cfg(feature = "postgres_backend")]
159pub type IsJsonScalar<T> = super::operators::IsJsonScalar<T>;
160
161#[cfg(feature = "postgres_backend")]
163pub type IsNotJsonScalar<T> = super::operators::IsNotJsonScalar<T>;
164
165#[cfg(feature = "postgres_backend")]
167pub type NullsLast<T> = super::operators::NullsLast<T>;
168
169#[cfg(feature = "postgres_backend")]
171pub type AtTimeZone<Lhs, Rhs> =
172 Grouped<super::date_and_time::AtTimeZone<Lhs, AsExprOf<Rhs, VarChar>>>;
173
174#[cfg(feature = "postgres_backend")]
177pub type ContainsNet<Lhs, Rhs> = Grouped<super::operators::ContainsNet<Lhs, AsExprOf<Rhs, Inet>>>;
178
179#[cfg(feature = "postgres_backend")]
181pub type ContainsNetLoose<Lhs, Rhs> =
182 Grouped<super::operators::ContainsNetLoose<Lhs, AsExprOf<Rhs, Inet>>>;
183
184#[doc(hidden)] pub type ContainsOrEq<Lhs, Rhs> = ContainsNetLoose<Lhs, Rhs>;
186
187#[cfg(feature = "postgres_backend")]
190pub type IsContainedByNet<Lhs, Rhs> =
191 Grouped<super::operators::IsContainedByNet<Lhs, AsExprOf<Rhs, Inet>>>;
192
193#[cfg(feature = "postgres_backend")]
195pub type IsContainedByNetLoose<Lhs, Rhs> =
196 Grouped<super::operators::IsContainedByNetLoose<Lhs, AsExprOf<Rhs, Inet>>>;
197
198#[doc(hidden)] pub type IsContainedByOrEq<Lhs, Rhs> = IsContainedByNetLoose<Lhs, Rhs>;
200
201#[cfg(feature = "postgres_backend")]
204pub type OverlapsWithNet<Lhs, Rhs> =
205 Grouped<super::operators::OverlapsWith<Lhs, AsExprOf<Rhs, Inet>>>;
206
207#[cfg(feature = "postgres_backend")]
209pub type AndNet<Lhs, Rhs> = Grouped<super::operators::AndNet<Lhs, AsExprOf<Rhs, Inet>>>;
210
211#[cfg(feature = "postgres_backend")]
213pub type OrNet<Lhs, Rhs> = Grouped<super::operators::OrNet<Lhs, AsExprOf<Rhs, Inet>>>;
214
215#[cfg(feature = "postgres_backend")]
217pub type DifferenceNet<Lhs, Rhs> =
218 Grouped<super::operators::DifferenceNet<Lhs, AsExprOf<Rhs, Inet>>>;
219
220#[doc(hidden)] pub type Diff<Lhs, Rhs> = DifferenceNet<Lhs, Rhs>;
222
223#[doc(hidden)]
224#[deprecated(note = "Use `dsl::Concat` instead")]
225pub type ConcatJsonb<Lhs, Rhs> = crate::dsl::Concat<Lhs, Rhs>;
226
227#[cfg(feature = "postgres_backend")]
229pub type HasKeyJsonb<Lhs, Rhs> =
230 Grouped<super::operators::HasKeyJsonb<Lhs, AsExprOf<Rhs, VarChar>>>;
231
232#[doc(hidden)] pub type HasKey<Lhs, Rhs> = HasKeyJsonb<Lhs, Rhs>;
234
235#[cfg(feature = "postgres_backend")]
237pub type HasAnyKeyJsonb<Lhs, Rhs> =
238 Grouped<super::operators::HasAnyKeyJsonb<Lhs, AsExprOf<Rhs, Array<VarChar>>>>;
239
240#[doc(hidden)] pub type HasAnyKey<Lhs, Rhs> = HasAnyKeyJsonb<Lhs, Rhs>;
242
243#[cfg(feature = "postgres_backend")]
245pub type HasAllKeysJsonb<Lhs, Rhs> =
246 Grouped<super::operators::HasAllKeysJsonb<Lhs, AsExprOf<Rhs, Array<VarChar>>>>;
247
248#[doc(hidden)] pub type HasAllKeys<Lhs, Rhs> = HasAllKeysJsonb<Lhs, Rhs>;
250
251#[doc(hidden)]
252#[deprecated(note = "Use `dsl::Contains` instead")]
253pub type ContainsJsonb<Lhs, Rhs> = Contains<Lhs, Rhs>;
254
255#[doc(hidden)]
256#[deprecated(note = "Use `dsl::IsContainedBy` instead")]
257pub type IsContainedByJsonb<Lhs, Rhs> = IsContainedBy<Lhs, Rhs>;
258
259#[cfg(feature = "postgres_backend")]
261pub type Index<Lhs, Rhs> = super::operators::ArrayIndex<Lhs, AsExprOf<Rhs, Integer>>;
262
263#[doc(hidden)]
264#[deprecated(note = "Use `Index` instead")]
265pub type ArrayIndex<Lhs, Rhs> = Index<Lhs, Rhs>;
266
267#[cfg(feature = "postgres_backend")]
269pub type RemoveFromJsonb<Lhs, Rhs, ST> =
270 Grouped<super::operators::RemoveFromJsonb<Lhs, AsExprOf<Rhs, ST>>>;
271
272#[doc(hidden)] pub type Remove<Lhs, Rhs> = RemoveFromJsonb<
274 Lhs,
275 <Rhs as JsonRemoveIndex>::Expression,
276 <<Rhs as JsonRemoveIndex>::Expression as Expression>::SqlType,
277>;
278
279#[cfg(feature = "postgres_backend")]
281pub type RetrieveAsObjectJson<Lhs, Rhs, ST> =
282 Grouped<super::operators::RetrieveAsObjectJson<Lhs, AsExprOf<Rhs, ST>>>;
283
284#[doc(hidden)] pub type RetrieveAsObject<Lhs, Rhs> = RetrieveAsObjectJson<
286 Lhs,
287 <Rhs as JsonIndex>::Expression,
288 <<Rhs as JsonIndex>::Expression as Expression>::SqlType,
289>;
290
291#[cfg(feature = "postgres_backend")]
293pub type RetrieveAsTextJson<Lhs, Rhs, ST> =
294 Grouped<super::operators::RetrieveAsTextJson<Lhs, AsExprOf<Rhs, ST>>>;
295
296#[doc(hidden)] pub type RetrieveAsText<Lhs, Rhs> = RetrieveAsTextJson<
298 Lhs,
299 <Rhs as JsonIndex>::Expression,
300 <<Rhs as JsonIndex>::Expression as Expression>::SqlType,
301>;
302
303#[cfg(feature = "postgres_backend")]
305pub type RetrieveByPathAsObjectJson<Lhs, Rhs> =
306 Grouped<super::operators::RetrieveByPathAsObjectJson<Lhs, AsExprOf<Rhs, Array<VarChar>>>>;
307
308#[doc(hidden)] pub type RetrieveByPathAsObject<Lhs, Rhs> = RetrieveByPathAsObjectJson<Lhs, Rhs>;
310
311#[cfg(feature = "postgres_backend")]
313pub type RetrieveByPathAsTextJson<Lhs, Rhs> =
314 Grouped<super::operators::RetrieveByPathAsTextJson<Lhs, AsExprOf<Rhs, Array<VarChar>>>>;
315
316#[doc(hidden)] pub type RetrieveByPathAsText<Lhs, Rhs> = RetrieveByPathAsTextJson<Lhs, Rhs>;
318
319#[cfg(feature = "postgres_backend")]
321pub type RemoveByPathFromJsonb<Lhs, Rhs> =
322 Grouped<super::operators::RemoveByPathFromJsonb<Lhs, AsExprOf<Rhs, Array<VarChar>>>>;
323
324#[doc(hidden)] pub type RemoveByPath<Lhs, Rhs> = RemoveByPathFromJsonb<Lhs, Rhs>;
326
327#[doc(hidden)]
328#[deprecated(note = "Use `dsl::Concat` instead")]
329pub type ConcatBinary<Lhs, Rhs> = crate::dsl::Concat<Lhs, Rhs>;
330
331#[doc(hidden)]
332#[deprecated(note = "Use `dsl::Like` instead")]
333pub type LikeBinary<Lhs, Rhs> = crate::dsl::Like<Lhs, Rhs>;
334
335#[doc(hidden)]
336#[deprecated(note = "Use `dsl::NotLike` instead")]
337pub type NotLikeBinary<Lhs, Rhs> = crate::dsl::NotLike<Lhs, Rhs>;
338
339#[doc(hidden)]
340#[deprecated(note = "Use `dsl::Concat` instead")]
341pub type ConcatArray<Lhs, Rhs> = crate::dsl::Concat<Lhs, Rhs>;
342
343#[allow(non_camel_case_types)]
345#[cfg(feature = "postgres_backend")]
346pub type array_to_string_with_null_string<A, D, N> =
347 super::functions::array_to_string_with_null_string<
348 SqlTypeOf<A>, A, D, N, >;
353
354#[allow(non_camel_case_types)]
356#[cfg(feature = "postgres_backend")]
357pub type array_to_string<A, D> = super::functions::array_to_string<
358 SqlTypeOf<A>, A, D, >;
362
363#[allow(non_camel_case_types)]
365#[cfg(feature = "postgres_backend")]
366pub type lower<R> = super::functions::lower<SqlTypeOf<R>, R>;
367
368#[allow(non_camel_case_types)]
370#[cfg(feature = "postgres_backend")]
371pub type upper<R> = super::functions::upper<SqlTypeOf<R>, R>;
372
373#[allow(non_camel_case_types)]
375#[cfg(feature = "postgres_backend")]
376pub type isempty<R> = super::functions::isempty<SqlTypeOf<R>, R>;
377
378#[allow(non_camel_case_types)]
380#[cfg(feature = "postgres_backend")]
381pub type lower_inc<R> = super::functions::lower_inc<SqlTypeOf<R>, R>;
382
383#[allow(non_camel_case_types)]
385#[cfg(feature = "postgres_backend")]
386pub type upper_inc<R> = super::functions::upper_inc<SqlTypeOf<R>, R>;
387
388#[allow(non_camel_case_types)]
390#[cfg(feature = "postgres_backend")]
391pub type lower_inf<R> = super::functions::lower_inf<SqlTypeOf<R>, R>;
392
393#[allow(non_camel_case_types)]
395#[cfg(feature = "postgres_backend")]
396pub type upper_inf<R> = super::functions::upper_inf<SqlTypeOf<R>, R>;
397
398#[allow(non_camel_case_types)]
400#[cfg(feature = "postgres_backend")]
401pub type range_merge<R1, R2> = super::functions::range_merge<SqlTypeOf<R1>, SqlTypeOf<R2>, R1, R2>;
402
403#[allow(non_camel_case_types)]
405#[cfg(feature = "postgres_backend")]
406pub type multirange_merge<R> = super::functions::multirange_merge<SqlTypeOf<R>, R>;
407
408#[allow(non_camel_case_types)]
410#[cfg(feature = "postgres_backend")]
411pub type array_append<A, E> = super::functions::array_append<SqlTypeOf<A>, SqlTypeOf<E>, A, E>;
412
413#[allow(non_camel_case_types)]
415#[cfg(feature = "postgres_backend")]
416pub type array_replace<A, E, R> =
417 super::functions::array_replace<SqlTypeOf<A>, SqlTypeOf<E>, A, E, R>;
418
419#[allow(non_camel_case_types)]
421#[cfg(feature = "postgres_backend")]
422pub type array_dims<A> = super::functions::array_dims<SqlTypeOf<A>, A>;
423
424#[allow(non_camel_case_types)]
426#[cfg(feature = "postgres_backend")]
427pub type array_prepend<E, A> = super::functions::array_prepend<SqlTypeOf<E>, SqlTypeOf<A>, E, A>;
428
429#[allow(non_camel_case_types)]
431#[cfg(feature = "postgres_backend")]
432pub type array_remove<A, E> = super::functions::array_remove<SqlTypeOf<A>, SqlTypeOf<E>, A, E>;
433
434#[allow(non_camel_case_types)]
436#[cfg(feature = "postgres_backend")]
437pub type cardinality<A> = super::functions::cardinality<SqlTypeOf<A>, A>;
438
439#[allow(non_camel_case_types)]
441#[cfg(feature = "postgres_backend")]
442pub type trim_array<A, N> = super::functions::trim_array<SqlTypeOf<A>, A, N>;
443
444#[allow(non_camel_case_types)]
446#[cfg(feature = "postgres_backend")]
447pub type array_cat<A, B> = super::functions::array_cat<SqlTypeOf<A>, A, B>;
448
449#[allow(non_camel_case_types)]
451#[cfg(feature = "postgres_backend")]
452pub type array_length<A, D> = super::functions::array_length<SqlTypeOf<A>, A, D>;
453
454#[allow(non_camel_case_types)]
456#[cfg(feature = "postgres_backend")]
457pub type array_fill<E, A> = super::functions::array_fill<SqlTypeOf<E>, E, A>;
458
459#[allow(non_camel_case_types)]
461#[cfg(feature = "postgres_backend")]
462pub type array_fill_with_lower_bound<E, A1, A2> =
463 super::functions::array_fill_with_lower_bound<SqlTypeOf<E>, E, A1, A2>;
464
465#[allow(non_camel_case_types)]
467#[cfg(feature = "postgres_backend")]
468pub type array_lower<A, D> = super::functions::array_lower<SqlTypeOf<A>, A, D>;
469
470#[allow(non_camel_case_types)]
472#[cfg(feature = "postgres_backend")]
473pub type array_upper<A, D> = super::functions::array_upper<SqlTypeOf<A>, A, D>;
474
475#[allow(non_camel_case_types)]
477#[cfg(feature = "postgres_backend")]
478pub type array_position<A, E> = super::functions::array_position<SqlTypeOf<A>, SqlTypeOf<E>, A, E>;
479
480#[allow(non_camel_case_types)]
482#[cfg(feature = "postgres_backend")]
483pub type array_position_with_subscript<A, E, S> =
484 super::functions::array_position_with_subscript<SqlTypeOf<A>, SqlTypeOf<E>, A, E, S>;
485
486#[allow(non_camel_case_types)]
488#[cfg(feature = "postgres_backend")]
489pub type array_positions<A, E> =
490 super::functions::array_positions<SqlTypeOf<A>, SqlTypeOf<E>, A, E>;
491
492#[allow(non_camel_case_types)]
494#[cfg(feature = "postgres_backend")]
495pub type array_ndims<A> = super::functions::array_ndims<SqlTypeOf<A>, A>;
496
497#[allow(non_camel_case_types)]
499#[cfg(feature = "postgres_backend")]
500pub type array_shuffle<A> = super::functions::array_shuffle<SqlTypeOf<A>, A>;
501
502#[allow(non_camel_case_types)]
504#[cfg(feature = "postgres_backend")]
505pub type array_sample<A, N> = super::functions::array_sample<SqlTypeOf<A>, A, N>;
506
507#[allow(non_camel_case_types)]
509#[cfg(feature = "postgres_backend")]
510pub type array_to_json<A> = super::functions::array_to_json<SqlTypeOf<A>, A>;
511
512#[allow(non_camel_case_types)]
514#[cfg(feature = "postgres_backend")]
515pub type to_json<E> = super::functions::to_json<SqlTypeOf<E>, E>;
516
517#[allow(non_camel_case_types)]
519#[cfg(feature = "postgres_backend")]
520pub type to_jsonb<E> = super::functions::to_jsonb<SqlTypeOf<E>, E>;
521
522#[allow(non_camel_case_types)]
524#[cfg(feature = "postgres_backend")]
525pub type json_object<A> = super::functions::json_object<SqlTypeOf<A>, A>;
526
527#[allow(non_camel_case_types)]
529#[cfg(feature = "postgres_backend")]
530pub type json_object_with_keys_and_values<K, V> =
531 super::functions::json_object_with_keys_and_values<SqlTypeOf<K>, SqlTypeOf<V>, K, V>;
532
533#[allow(non_camel_case_types)]
535#[cfg(feature = "postgres_backend")]
536pub type json_typeof<E> = super::functions::json_typeof<SqlTypeOf<E>, E>;
537
538#[allow(non_camel_case_types)]
540#[cfg(feature = "postgres_backend")]
541pub type jsonb_typeof<E> = super::functions::jsonb_typeof<SqlTypeOf<E>, E>;
542
543#[allow(non_camel_case_types)]
545#[cfg(feature = "postgres_backend")]
546pub type jsonb_pretty<E> = super::functions::jsonb_pretty<SqlTypeOf<E>, E>;
547
548#[allow(non_camel_case_types)]
550#[cfg(feature = "postgres_backend")]
551pub type json_strip_nulls<E> = super::functions::json_strip_nulls<SqlTypeOf<E>, E>;
552
553#[allow(non_camel_case_types)]
555#[cfg(feature = "postgres_backend")]
556pub type jsonb_strip_nulls<E> = super::functions::jsonb_strip_nulls<SqlTypeOf<E>, E>;
557
558#[allow(non_camel_case_types)]
560#[cfg(feature = "postgres_backend")]
561pub type json_array_length<E> = super::functions::json_array_length<SqlTypeOf<E>, E>;
562
563#[allow(non_camel_case_types)]
565#[cfg(feature = "postgres_backend")]
566pub type jsonb_array_length<E> = super::functions::jsonb_array_length<SqlTypeOf<E>, E>;
567
568#[allow(non_camel_case_types)]
570#[cfg(feature = "postgres_backend")]
571pub type jsonb_object<A> = super::functions::jsonb_object<SqlTypeOf<A>, A>;
572
573#[allow(non_camel_case_types)]
575#[cfg(feature = "postgres_backend")]
576pub type jsonb_object_with_keys_and_values<K, V> =
577 super::functions::jsonb_object_with_keys_and_values<SqlTypeOf<K>, SqlTypeOf<V>, K, V>;
578
579#[allow(non_camel_case_types)]
581#[cfg(feature = "postgres_backend")]
582pub type row_to_json<R> = super::functions::row_to_json<SqlTypeOf<R>, R>;
583
584#[allow(non_camel_case_types)]
586#[cfg(feature = "postgres_backend")]
587pub type json_populate_record<B, J> =
588 super::functions::json_populate_record<SqlTypeOf<B>, SqlTypeOf<J>, B, J>;
589
590#[allow(non_camel_case_types)]
592#[cfg(feature = "postgres_backend")]
593pub type jsonb_populate_record<B, J> =
594 super::functions::jsonb_populate_record<SqlTypeOf<B>, SqlTypeOf<J>, B, J>;
595
596#[allow(non_camel_case_types)]
598#[cfg(feature = "postgres_backend")]
599pub type jsonb_set<B, J, R> = super::functions::jsonb_set<SqlTypeOf<B>, SqlTypeOf<J>, B, J, R>;
600
601#[allow(non_camel_case_types)]
603#[cfg(feature = "postgres_backend")]
604pub type jsonb_set_create_if_missing<B, J, R, C> =
605 super::functions::jsonb_set_create_if_missing<SqlTypeOf<B>, SqlTypeOf<J>, B, J, R, C>;
606
607#[allow(non_camel_case_types)]
609#[cfg(feature = "postgres_backend")]
610pub type jsonb_set_lax<B, J, R, C, E> =
611 super::functions::jsonb_set_lax<SqlTypeOf<B>, SqlTypeOf<J>, B, J, R, C, E>;
612
613#[allow(non_camel_case_types)]
615#[cfg(feature = "postgres_backend")]
616pub type jsonb_insert<B, J, R> =
617 super::functions::jsonb_insert<SqlTypeOf<B>, SqlTypeOf<J>, B, J, R>;
618
619#[allow(non_camel_case_types)]
621#[cfg(feature = "postgres_backend")]
622pub type jsonb_insert_with_insert_after<B, J, R, I> =
623 super::functions::jsonb_insert_with_insert_after<SqlTypeOf<B>, SqlTypeOf<J>, B, J, R, I>;