connect simple methods

README.md

@@ -8,9 +8,8 @@ This crate provides Sqlx integration for [ydb-rs-sdk](https://github.com/ydb-pla
 ```rust 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn Error>> {
-    let connection_string = env::var("YDB_CONNECTION_STRING")?;
 
-    let pool = YdbPoolOptions::new().connect(&connection_string).await?;
+    let pool = Ydb::connect_env().await?;
     let row: (i32,) = sqlx::query_as("SELECT 1+1").fetch_one(&pool).await?;
     assert_eq!(row.0, 2);
 
@@ -30,10 +29,9 @@ struct UserInfo {
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn Error>> {
-    let connection_string = env::var("YDB_CONNECTION_STRING")?;
-    let pool = YdbPoolOptions::new().connect(&connection_string).await?;
+    let pool = Ydb::connect_env().await?;
 
-     let users: Vec<UserInfo> =
+    let users: Vec<UserInfo> =
         sqlx::query_as("SELECT * FROM test2 WHERE age >= $min_age AND age <= $max_age")
             .bind(("min_age", 30))
             .bind(("max_age", 40))

example/Cargo.toml

@@ -8,7 +8,7 @@ edition = "2021"
 [dependencies]
 tokio = { version = "1.22", features = ["full"] }
 sqlx = { version = "0.8", features = ["runtime-tokio-rustls"] }
-tracing-subscriber = "0.3"
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 tracing = "0.1"
 tracing-log = "0.2"
 ydb-sqlx = { path = "../ydb-sqlx" }

example/src/main.rs

@@ -1,21 +1,17 @@
-use std::{env, str::FromStr};
+use tracing::info;
+use tracing_log::log::LevelFilter;
+use tracing_subscriber::{fmt, layer::SubscriberExt, util::SubscriberInitExt, EnvFilter};
+use ydb_sqlx::database::Ydb;
 
-use tracing::{info, Level};
-
-use ydb_sqlx::{connection::YdbConnectOptions, YdbPoolOptions};
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     dotenvy::dotenv().ok();
     init_logs();
-    let connection_string = env::var("YDB_CONNECTION_STRING").unwrap_or_else(|_| "grpc://localhost:2136?database=/local".to_string());
-
-    let options = YdbConnectOptions::from_str(&connection_string)?
-        ;
-        //.log_statements(LevelFilter::Info); 
 
+    let pool = Ydb::connect_env_opts(
+        |opt|opt.log_statements(LevelFilter::Info)
+    ).await?;
 
-    let pool = YdbPoolOptions::new()        
-        .connect_with(options).await?;
     let row: (i32,) = sqlx::query_as("SELECT 1+1").fetch_one(&pool).await?;
     assert_eq!(row.0, 2);
 
@@ -68,10 +64,8 @@ struct UserInfo {
 }
 
 fn init_logs() {
-    let level = env::var("RUST_LOG").unwrap_or("INFO".to_string());
-    let log_level = Level::from_str(&level).unwrap();
-    let subscriber = tracing_subscriber::FmtSubscriber::builder()
-        .with_max_level(log_level)
-        .finish();
-    tracing::subscriber::set_global_default(subscriber).expect("Error setting subscriber");
+    tracing_subscriber::registry()
+        .with(fmt::layer())
+        .with(EnvFilter::from_default_env())
+        .init();
 }

ydb-sqlx/src/connection/mod.rs

@@ -125,6 +125,22 @@ impl From<&StatsMode> for ydb::QueryStatsMode {
 
 impl YdbConnectOptions{
 
+    pub fn from_env() -> Result<Self, sqlx_core::Error> {
+
+        let ydb_conn_str = std::env::var("YDB_CONNECTION_STRING").ok();
+
+        if let Some(ydb_conn_str) = ydb_conn_str {
+            return Self::from_url(&url::Url::parse(&ydb_conn_str)
+            .map_err(|e| sqlx_core::Error::Configuration(e.into()))?);
+        }
+
+        let db_url = std::env::var("DATABASE_URL").map_err(|e| sqlx_core::Error::Configuration(e.into()))?;
+
+
+        Self::from_url(&url::Url::parse(&db_url)
+            .map_err(|e| sqlx_core::Error::Configuration(e.into()))?)
+    }
+
     pub fn  log_statements(mut self, level: tracing::log::LevelFilter) -> Self {
         self.log_settings.log_statements(level);
         self
@@ -148,6 +164,7 @@ impl YdbConnectOptions{
 impl ConnectOptions for YdbConnectOptions {
     type Connection = YdbConnection;
 
+
     fn from_url(url: &url::Url) -> Result<Self, sqlx_core::Error> {
         Self::from_str(url.as_str())
     }

ydb-sqlx/src/database.rs

@@ -1,6 +1,6 @@
-use sqlx_core::database::{Database, HasStatementCache};
+use sqlx_core::{connection::ConnectOptions, database::{Database, HasStatementCache}};
 
-use crate::value::YdbValueRef;
+use crate::{connection::YdbConnectOptions, value::YdbValueRef, YdbPool, YdbPoolOptions};
 
 use super::{
     arguments::{YdbArgumentBuffer, YdbArguments},
@@ -46,3 +46,36 @@ impl Database for Ydb {
 }
 
 impl HasStatementCache for Ydb {}
+
+impl Ydb {
+    pub async fn connect_env() -> Result<YdbPool, sqlx_core::Error> {
+        let options = YdbConnectOptions::from_env()?;
+        let pool = YdbPoolOptions::new().connect_with(options).await?;
+        Ok(pool)
+    }
+
+    pub async fn connect_env_opts(opts: impl Fn(YdbConnectOptions)->YdbConnectOptions) -> Result<YdbPool, sqlx_core::Error> {
+        let options = YdbConnectOptions::from_env()?;
+        let options = opts(options);
+        let pool = YdbPoolOptions::new().connect_with(options).await?;
+        Ok(pool)
+    }
+
+
+    pub async fn connect(db_url: &str)->Result<YdbPool,sqlx_core::Error>{
+        let url = url::Url::parse(&db_url)
+            .map_err(|e| sqlx_core::Error::Configuration(e.into()))?;
+        let options = YdbConnectOptions::from_url(&url)?;
+        let pool = YdbPoolOptions::new().connect_with(options).await?;
+        Ok(pool)
+    }
+
+    pub async fn connect_opts(db_url: &str, opts: impl Fn(YdbConnectOptions)->YdbConnectOptions)->Result<YdbPool,sqlx_core::Error>{
+        let url = url::Url::parse(&db_url)
+            .map_err(|e| sqlx_core::Error::Configuration(e.into()))?;
+        let options = YdbConnectOptions::from_url(&url)?;
+        let options = opts(options);
+        let pool = YdbPoolOptions::new().connect_with(options).await?;
+        Ok(pool)
+    }
+}