@@ -2,81 +2,101 @@ use tokio_postgres::{Client, NoTls};
2
2
3
3
use crate :: Error ;
4
4
5
- pub async fn connect ( url : & str ) -> Result < Client , Error > {
6
- let ( client, connection) = tokio_postgres:: connect ( url, NoTls ) . await ?;
7
-
8
- tokio:: spawn ( async move {
9
- if let Err ( e) = connection. await {
10
- eprintln ! ( "connection error: {}" , e) ;
11
- }
12
- } ) ;
13
-
14
- Ok ( client)
5
+ // const QUERY_GET_METRICS: &str = "
6
+ // SELECT
7
+ // usename,
8
+ // SUM(calls) AS total_queries,
9
+ // SUM(total_exec_time) AS total_exec_time
10
+ // FROM
11
+ // pg_stat_statements
12
+ // inner join
13
+ // pg_catalog.pg_user on pg_catalog.pg_user.usesysid = userid
14
+ // GROUP BY
15
+ // usename;";
16
+
17
+ pub struct Postgres {
18
+ client : Client ,
15
19
}
16
20
17
- pub async fn user_create ( client : & mut Client , username : & str , password : & str ) -> Result < ( ) , Error > {
18
- let query_create_user = format ! ( "create user \" {username}\" with password '{password}';" ) ;
19
- let query_create_role =
20
- format ! ( "grant select on all tables in schema public to \" {username}\" ;" ) ;
21
+ impl Postgres {
22
+ pub async fn new ( url : & str ) -> Result < Self , Error > {
23
+ let ( client, connection) = tokio_postgres:: connect ( url, NoTls ) . await ?;
21
24
22
- let tx = client. transaction ( ) . await ?;
25
+ tokio:: spawn ( async move {
26
+ if let Err ( e) = connection. await {
27
+ eprintln ! ( "connection error: {}" , e) ;
28
+ }
29
+ } ) ;
23
30
24
- let user_stmt = tx. prepare ( & query_create_user) . await ?;
25
- let user_result = tx. execute ( & user_stmt, & [ ] ) . await ;
26
- if let Err ( err) = user_result {
27
- tx. rollback ( ) . await ?;
28
- return Err ( Error :: PgError ( err) ) ;
31
+ Ok ( Self { client } )
29
32
}
30
33
31
- let role_stmt = tx. prepare ( & query_create_role) . await ?;
32
- let role_result = tx. execute ( & role_stmt, & [ ] ) . await ;
33
- if let Err ( err) = role_result {
34
- tx. rollback ( ) . await ?;
35
- return Err ( Error :: PgError ( err) ) ;
36
- }
34
+ pub async fn user_create ( & mut self , username : & str , password : & str ) -> Result < ( ) , Error > {
35
+ let query_create_user = format ! ( "create user \" {username}\" with password '{password}';" ) ;
36
+ let query_create_role =
37
+ format ! ( "grant select on all tables in schema public to \" {username}\" ;" ) ;
37
38
38
- tx. commit ( ) . await ?;
39
- Ok ( ( ) )
40
- }
39
+ let tx = self . client . transaction ( ) . await ?;
41
40
42
- pub async fn user_disable ( client : & mut Client , username : & str ) -> Result < ( ) , Error > {
43
- let query_revoke_login = format ! ( "alter user \" {username}\" with nologin;" ) ;
41
+ let user_stmt = tx. prepare ( & query_create_user) . await ?;
42
+ let user_result = tx. execute ( & user_stmt, & [ ] ) . await ;
43
+ if let Err ( err) = user_result {
44
+ tx. rollback ( ) . await ?;
45
+ return Err ( Error :: PgError ( err) ) ;
46
+ }
44
47
45
- let revoke_stmt = client. prepare ( & query_revoke_login) . await ?;
46
- client. execute ( & revoke_stmt, & [ ] ) . await ?;
48
+ let role_stmt = tx. prepare ( & query_create_role) . await ?;
49
+ let role_result = tx. execute ( & role_stmt, & [ ] ) . await ;
50
+ if let Err ( err) = role_result {
51
+ tx. rollback ( ) . await ?;
52
+ return Err ( Error :: PgError ( err) ) ;
53
+ }
47
54
48
- Ok ( ( ) )
49
- }
55
+ tx. commit ( ) . await ?;
56
+ Ok ( ( ) )
57
+ }
50
58
51
- pub async fn user_enable ( client : & mut Client , username : & str , password : & str ) -> Result < ( ) , Error > {
52
- let query_grant_login = format ! ( "alter user \" {username}\" with login;" ) ;
53
- let query_alter_password = format ! ( "alter user \" {username}\" with password '{password}';" ) ;
59
+ pub async fn user_disable ( & self , username : & str ) -> Result < ( ) , Error > {
60
+ let query_revoke_login = format ! ( "alter user \" {username}\" with nologin;" ) ;
54
61
55
- let tx = client. transaction ( ) . await ?;
62
+ let revoke_stmt = self . client . prepare ( & query_revoke_login) . await ?;
63
+ self . client . execute ( & revoke_stmt, & [ ] ) . await ?;
56
64
57
- let login_stmt = tx. prepare ( & query_grant_login) . await ?;
58
- let login_result = tx. execute ( & login_stmt, & [ ] ) . await ;
59
- if let Err ( err) = login_result {
60
- tx. rollback ( ) . await ?;
61
- return Err ( Error :: PgError ( err) ) ;
65
+ Ok ( ( ) )
62
66
}
63
67
64
- let alter_stmt = tx. prepare ( & query_alter_password) . await ?;
65
- let alter_result = tx. execute ( & alter_stmt, & [ ] ) . await ;
66
- if let Err ( err) = alter_result {
67
- tx. rollback ( ) . await ?;
68
- return Err ( Error :: PgError ( err) ) ;
69
- }
68
+ pub async fn user_enable ( & mut self , username : & str , password : & str ) -> Result < ( ) , Error > {
69
+ let query_grant_login = format ! ( "alter user \" {username}\" with login;" ) ;
70
+ let query_alter_password = format ! ( "alter user \" {username}\" with password '{password}';" ) ;
70
71
71
- tx. commit ( ) . await ?;
72
- Ok ( ( ) )
73
- }
72
+ let tx = self . client . transaction ( ) . await ?;
74
73
75
- pub async fn user_already_exists ( client : & mut Client , username : & str ) -> Result < bool , Error > {
76
- let query = "select rolname from pg_roles where rolname = $1;" ;
74
+ let login_stmt = tx. prepare ( & query_grant_login) . await ?;
75
+ let login_result = tx. execute ( & login_stmt, & [ ] ) . await ;
76
+ if let Err ( err) = login_result {
77
+ tx. rollback ( ) . await ?;
78
+ return Err ( Error :: PgError ( err) ) ;
79
+ }
77
80
78
- let user_stmt = client. prepare ( query) . await ?;
79
- let result = client. query_opt ( & user_stmt, & [ & username] ) . await ?;
81
+ let alter_stmt = tx. prepare ( & query_alter_password) . await ?;
82
+ let alter_result = tx. execute ( & alter_stmt, & [ ] ) . await ;
83
+ if let Err ( err) = alter_result {
84
+ tx. rollback ( ) . await ?;
85
+ return Err ( Error :: PgError ( err) ) ;
86
+ }
87
+
88
+ tx. commit ( ) . await ?;
89
+ Ok ( ( ) )
90
+ }
80
91
81
- Ok ( result. is_some ( ) )
92
+ pub async fn user_already_exists ( & self , username : & str ) -> Result < bool , Error > {
93
+ let query = "select rolname from pg_roles where rolname = $1;" ;
94
+
95
+ let user_stmt = self . client . prepare ( query) . await ?;
96
+ let result = self . client . query_opt ( & user_stmt, & [ & username] ) . await ?;
97
+
98
+ Ok ( result. is_some ( ) )
99
+ }
82
100
}
101
+
102
+ pub async fn get_metrics ( ) { }
0 commit comments