Skip to main content

datasources_postgres/
lib.rs

1mod 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}