Fixed Retries

Author: amigin

README.md

@@ -28,7 +28,31 @@ my-postgres = { tag = "xxx", git = "https://github.com/MyJetTools/my-postgres.gi
 ```
 whether to use TLS or not is detected by **sslmode=require** in the connection string
 
+### SSH Connection
 
+For the sake of optimization - the SSH feature is not included by default.
+
+If you are planning to use connections with SSH tunneling, please add a feature
+
+```toml
+[dependencies]
+my-postgres = { tag = "xxx", git = "https://github.com/MyJetTools/my-postgres.git", features = [
+    "with-ssh",
+] }
+```
+
+It is possible to connect to a PostgreSQL database through an SSH tunnel by adding the `ssh` parameter to the connection string. The format is `ssh=user@sshhost:22` where:
+- `user` is the SSH username
+- `sshhost` is the SSH server hostname or IP address
+- `22` is the SSH port (default is 22)
+
+Example connection string with SSH tunneling:
+
+```
+host=xxx port=5432 dbname=xxx user=xxx password=xxx ssh=user@sshhost:22
+```
+
+The SSH tunnel will be established automatically, and the connection to PostgreSQL will be routed through it.
 
 ### Application name
 

my-postgres-core/src/connection/postgres_connect_inner.rs

@@ -477,11 +477,45 @@ impl PostgresConnectionInner {
         Ok(())
     }
 
+    fn is_non_retryable_postgres_error(err: &tokio_postgres::Error) -> bool {
+        if let Some(state) = err.code() {
+            let code = state.code();
+            if code == "42P01" // undefined_table (relation does not exist)
+                || code == "3D000" // invalid_catalog_name (database does not exist)
+                || code == "28P01" // invalid_authorization_specification (invalid password)
+                || code == "42704" // undefined_object (object does not exist)
+                || code == "42601" // syntax_error (SQL syntax error)
+                || code == "42501" // insufficient_privilege (permission denied)
+                || code == "42703" // undefined_column (column does not exist)
+                || code == "42883" // undefined_function (function does not exist)
+                || code == "23502" // not_null_violation (NOT NULL constraint violation)
+                || code == "23503" // foreign_key_violation (foreign key constraint violation)
+                || code == "23505" // unique_violation (unique constraint violation)
+                || code == "22001" // string_data_right_truncation (string too long for column)
+                || code == "22003" // numeric_value_out_of_range (numeric value out of range)
+                || code == "22007" // invalid_datetime_format (invalid date/time format)
+                || code == "22008" // datetime_field_overflow (date/time field out of range)
+                || code == "22012"
+            // division_by_zero (division by zero)
+            {
+                return true;
+            }
+        }
+        false
+    }
+
     fn handle_error(
         &self,
         err: MyPostgresError,
         ctx: &crate::RequestContext,
     ) -> Result<(), MyPostgresError> {
+        // Check if this is a non-retryable PostgresError and return immediately
+        if let MyPostgresError::PostgresError(ref postgres_err) = &err {
+            if Self::is_non_retryable_postgres_error(postgres_err) {
+                return Err(err);
+            }
+        }
+
         match &err {
             MyPostgresError::NoConnection => {}
             MyPostgresError::SingleRowRequestReturnedMultipleRows(_) => {}

my-postgres-macros/src/attributes/where_operator.rs

@@ -18,6 +18,8 @@ pub enum WhereOperator {
     NotEqual2,
     #[value("like")]
     Like,
+    #[value("not")]
+    Not,
 }
 
 impl WhereOperator {
@@ -31,6 +33,7 @@ impl WhereOperator {
             Self::NotEqual => "!=",
             Self::NotEqual2 => "<>",
             Self::Like => " like ",
+            Self::Not => " not ",
         }
     }
 }