datasources_postgres/
lib.rs1mod alter_table_statement_renderer;
2mod bind;
3mod command;
4mod connection;
5mod converters;
6mod create_table_statement_renderer;
7mod create_trigger_statement_renderer;
8mod drop_routine_statement_renderer;
9mod driver;
10mod identity_insert_statement_renderer;
11mod default_value_converter;
12mod default_value_options;
13mod sql_generate;
14mod type_map;
15mod pg_value;
16mod reader;
17mod select_inserted_id_statement_text_renderer;
18mod sql_seed_statement_renderer;
19mod statement_renderer;
20mod stored_procedure_statement_renderer;
21mod transaction;
22
23pub use driver::PostgresDriver;
24
25#[cfg(test)]
26#[path = "../tests/isolate.rs"]
27mod isolate;
28#[cfg(test)]
29#[path = "../tests/contacts.rs"]
30mod contacts;
31#[cfg(test)]
32#[path = "../tests/integration.rs"]
33mod integration;
34#[cfg(test)]
35#[path = "../tests/repository_spec.rs"]
36mod repository_spec;
37#[cfg(test)]
38#[path = "../tests/generate_sql.rs"]
39mod generate_sql;
40#[cfg(test)]
41#[path = "../tests/driver_converters.rs"]
42mod driver_converters;
43#[cfg(test)]
44#[path = "../tests/generate_sql_casing.rs"]
45mod generate_sql_casing;
46#[cfg(test)]
47#[path = "../tests/generate_sql_mapping.rs"]
48mod generate_sql_mapping;
49
50#[cfg(test)]
51mod tests {
52 use crate::bind::{param_type, to_postgres};
53 use crate::connection::isolation_sql;
54 use crate::converters::BinaryConverter;
55 use tokio_postgres::types::Type;
56 use crate::command::PostgresCommand;
57 use crate::connection::PostgresConnection;
58 use crate::transaction::PostgresTransaction;
59 use datasources::{
60 Row, create, downcast_connection, register, reset, Command, Connection,
61 Driver, IsolationLevel, Transaction, TypeConverter, Value,
62 };
63 use std::collections::HashMap;
64 use std::sync::Arc;
65
66 struct With(Option<String>);
67
68 impl Driver for With {
69 fn connection(&self, _: Option<&HashMap<String, String>>) -> Arc<dyn Connection> {
70 Arc::new(PostgresConnection::new(self.0.clone(), None))
71 }
72
73 fn command(&self, connection: Arc<dyn Connection>) -> Arc<dyn Command> {
74 connection.create_command()
75 }
76
77 fn transaction(
78 &self,
79 connection: Arc<dyn Connection>,
80 isolation: IsolationLevel,
81 ) -> Arc<dyn Transaction> {
82 let conn = downcast_connection::<PostgresConnection>(connection).expect("postgres");
83 Arc::new(PostgresTransaction::new(conn.share(), isolation))
84 }
85
86 fn row_type_converters(
87 &self,
88 ) -> HashMap<
89 String,
90 Box<
91 dyn datasources::TypeConverter<datasources::Value, datasources::Value>
92 + Send
93 + Sync,
94 >,
95 > {
96 crate::converters::row_type_converters()
97 }
98 }
99
100 #[tokio::test]
101 async fn postgres_command_and_repository() {
102 let (sql, values) = to_postgres(
103 "SELECT * FROM t WHERE id = $id AND n = $id",
104 &HashMap::from([("id".into(), Value::Int(1))]),
105 );
106 assert_eq!(sql, "SELECT * FROM t WHERE id = $1 AND n = $1");
107 assert_eq!(values, vec![Value::Int(1)]);
108 let (seed, _) = to_postgres(
109 "INSERT INTO \"contact_sources\" (\"name\") VALUES ('Manual')",
110 &HashMap::new(),
111 );
112 assert_eq!(seed, "INSERT INTO \"contact_sources\" (\"name\") VALUES ('Manual')");
113 let (legacy, _) = to_postgres("SELECT * FROM OldContactsTbl", &HashMap::new());
114 assert_eq!(legacy, "SELECT * FROM \"OldContactsTbl\"");
115 let (_, missing) = to_postgres("SELECT $missing", &HashMap::new());
116 assert_eq!(missing, vec![Value::Null]);
117 let stamp = Value::from("2020-01-02T03:04:05.000Z");
118 assert_eq!(param_type(&stamp).oid(), 0);
119 assert_eq!(
120 param_type(&Value::DateTime(
121 chrono::DateTime::parse_from_rfc3339("2020-01-02T03:04:05.000Z")
122 .unwrap()
123 .with_timezone(&chrono::Utc)
124 )),
125 Type::TIMESTAMPTZ
126 );
127 assert_eq!(param_type(&Value::from("ada")).oid(), 0);
128 assert_eq!(
129 param_type(&Value::from("550e8400-e29b-41d4-a716-446655440000")).oid(),
130 0
131 );
132 assert!(matches!(
133 BinaryConverter.convert(&Value::from("AQ==")).unwrap(),
134 Value::Binary(_)
135 ));
136 assert_eq!(param_type(&Value::from("AA==")).oid(), 0);
137 assert_eq!(param_type(&Value::Binary(vec![0])), Type::BYTEA);
138 assert_eq!(param_type(&Value::Int(1)), Type::INT4);
139 assert_eq!(param_type(&Value::Int(i64::MAX)), Type::INT8);
140 assert_eq!(
141 isolation_sql(IsolationLevel::ReadUncommitted),
142 "READ UNCOMMITTED"
143 );
144 assert_eq!(
145 isolation_sql(IsolationLevel::ReadCommitted),
146 "READ COMMITTED"
147 );
148 assert_eq!(
149 isolation_sql(IsolationLevel::RepeatableRead),
150 "REPEATABLE READ"
151 );
152 assert_eq!(isolation_sql(IsolationLevel::Serializable), "SERIALIZABLE");
153 let conn = Arc::new(PostgresConnection::new(
154 Some("postgres://db/app".into()),
155 Some("s".into()),
156 ));
157 assert_eq!(conn.schema.as_deref(), Some("s"));
158 let command = PostgresCommand::new(conn.clone());
159 command
160 .execute_native(&datasources::Native::new(""), None)
161 .await
162 .unwrap();
163 command
164 .execute_reader_native(&datasources::Native::new(""), None)
165 .await
166 .unwrap();
167 assert!(conn.start_transaction(None).await.is_err());
168 conn.close().await.unwrap();
169 assert!(conn.ensure_open().is_err());
170 let defaulted = PostgresConnection::new(None, None);
171 assert_eq!(defaulted.url, "");
172 let options = HashMap::from([(
173 "DATASOURCE_URL".into(),
174 "postgres://db/app?schema=s".into(),
175 )]);
176 let from = downcast_connection::<PostgresConnection>(PostgresConnection::from_options(
177 Some(&options),
178 ))
179 .expect("postgres");
180 assert_eq!(from.url, "postgres://db/app?schema=s");
181 assert_eq!(from.schema.as_deref(), Some("s"));
182 assert_eq!(
183 crate::connection::connect_url("postgres://db/app?schema=s"),
184 "postgres://db/app"
185 );
186 assert_eq!(
187 crate::connection::connect_url(
188 "postgres://ds:ds@127.0.0.1:15432/datasources?schema=ds_x"
189 ),
190 "postgres://ds:ds@127.0.0.1:15432/datasources"
191 );
192 reset();
193 register("postgres", Arc::new(With(Some("postgres://db/app".into()))));
194 let ds = create(Some(&HashMap::from([(
195 "PROVIDER".into(),
196 "postgres".into(),
197 )])))
198 .unwrap();
199 assert_eq!(ds.provider(), "postgres");
200 assert!(ds.create_command(None).await.is_err());
201 ds.create_repository::<Row>(None, None);
202 let closed = Arc::new(PostgresConnection::new(None, None));
203 assert!(PostgresCommand::new(closed)
204 .execute_native(&datasources::Native::new("x"), None)
205 .await
206 .is_err());
207 }
208}