sqlb 0.4.0

Simple, expressive, and progressive SQL Builder for Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

//! Currently, `SqlxBindable` represents a value that can be bound.
//! This requires cloning the value. The performance impact should be minimal, and for bulk updates, direct usage of `sqlx` can be preferred.
//! Eventually, this might change to follow the `'args` pattern of `sqlx` `Builder`,
//! but at this point, priority is given to API ergonomics.
//!

use time::OffsetDateTime;
use uuid::Uuid;

pub trait SqlxBindable: std::fmt::Debug {
	fn bind_query<'q>(
		&'q self,
		query: sqlx::query::Query<'q, sqlx::Postgres, sqlx::postgres::PgArguments>,
	) -> sqlx::query::Query<'q, sqlx::Postgres, sqlx::postgres::PgArguments>;

	fn raw(&self) -> Option<&str> {
		None
	}
}

#[macro_export]
macro_rules! bindable {
    ($($t:ty),*) => {
        $(impl $crate::SqlxBindable for $t {
            fn bind_query<'q>(&self, query: sqlx::query::Query<'q, sqlx::Postgres, sqlx::postgres::PgArguments>) -> sqlx::query::Query<'q, sqlx::Postgres, sqlx::postgres::PgArguments> {
                let query = query.bind(self.clone());
                query
            }
        }

        impl $crate::SqlxBindable for &$t {
            fn bind_query<'q>(&self, query: sqlx::query::Query<'q, sqlx::Postgres, sqlx::postgres::PgArguments>) -> sqlx::query::Query<'q, sqlx::Postgres, sqlx::postgres::PgArguments> {
                let query = query.bind(<$t>::clone(self));
                query
            }
        }

        )*
    };
}

#[macro_export]
macro_rules! bindable_to_string {
	($($t:ident),*) => {
		$(
		impl $crate::SqlxBindable for $t {
			fn bind_query<'q>(&self, query: sqlx::query::Query<'q, sqlx::Postgres, sqlx::postgres::PgArguments>) -> sqlx::query::Query<'q, sqlx::Postgres, sqlx::postgres::PgArguments> {
				let query = query.bind(self.to_string());
				query
			}
		}

		impl $crate::SqlxBindable for &$t {
			fn bind_query<'q>(&self, query: sqlx::query::Query<'q, sqlx::Postgres, sqlx::postgres::PgArguments>) -> sqlx::query::Query<'q, sqlx::Postgres, sqlx::postgres::PgArguments> {
				let query = query.bind(self.to_string());
				query
			}
		}
		)*
	};
}

// Bind the string types
bindable_to_string!(String, str);

impl<T> SqlxBindable for Option<T>
where
	T: SqlxBindable + Clone + Send,
	T: for<'r> sqlx::Encode<'r, sqlx::Postgres>,
	T: sqlx::Type<sqlx::Postgres>,
{
	fn bind_query<'q>(
		&'q self,
		query: sqlx::query::Query<'q, sqlx::Postgres, sqlx::postgres::PgArguments>,
	) -> sqlx::query::Query<'q, sqlx::Postgres, sqlx::postgres::PgArguments> {
		let query = query.bind(self.clone());
		query
	}
}

// Bind the boolean
bindable!(bool);
// Bind the numbers
// NOTE: Skipping u8, u16, u64 since not mapped by sqlx to postgres.
bindable!(i8, i16, i32, i64, f32, f64);

bindable!(Uuid, OffsetDateTime);

// region:    --- Raw Value

// region: 		--- chrono support
#[cfg(feature = "chrono-support")]
mod chrono_support {
	use chrono::{NaiveDateTime, NaiveDate, NaiveTime, DateTime, Utc};

	bindable!(NaiveDateTime, NaiveDate, NaiveTime, DateTime<Utc>);
}
// endregion: --- chrono support


#[derive(Debug)]
pub struct Raw(pub &'static str);

impl SqlxBindable for Raw {
	// just return the query given, since no binding should be taken place
	fn bind_query<'q>(
		&self,
		query: sqlx::query::Query<'q, sqlx::Postgres, sqlx::postgres::PgArguments>,
	) -> sqlx::query::Query<'q, sqlx::Postgres, sqlx::postgres::PgArguments> {
		query
	}

	fn raw(&self) -> Option<&str> {
		Some(self.0)
	}
}
// endregion: --- Raw Value

#[cfg(test)]
mod tests {
	use crate::Field;

	#[test]
	fn field_from_str() {
		let field = Field::from(("name1", "v2"));
		assert_eq!("name1", field.name);

		let field: Field = ("name1", "v2").into();
		assert_eq!("name1", field.name);
	}

	#[test]
	fn field_from_string() {
		let field = Field::from(("name1", "v1"));
		assert_eq!("name1", field.name);

		let v2 = &"v2".to_string();
		let field: Field = ("name2", v2).into();
		assert_eq!("name2", field.name);
	}
}