SQLPyHelper 0.1.2__tar.gz → 0.1.3__tar.gz

{sqlpyhelper-0.1.2 → sqlpyhelper-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SQLPyHelper
-Version: 0.1.2
+Version: 0.1.3
 Summary: A simple SQL database helper package for Python.
 Author: Adebayo Olaonipekun
 Author-email: pekunmi@live.com
@@ -38,9 +38,9 @@ Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 
-# 📌 SQLPyHelper
+# 📌 SQLPyHelper v.0.1.3 🚀
 
-A Python library for simplified database interactions across **SQLite, PostgreSQL, MySQL, SQL Server, and Oracle**. This open-source package provides an intuitive API for handling database operations efficiently.
+A Python library for simplified database interactions across **SQLite, PostgreSQL, MySQL, SQL Server, and Oracle**. SQLPyHelper provides an intuitive API for handling queries, connection pooling, transactions, logging, and backups efficiently.
 
 ## 📖 Table of Contents
 - [🚀 Features](#-features)
@@ -53,17 +53,20 @@ A Python library for simplified database interactions across **SQLite, PostgreSQ
   - [SQL Server Example](#sql-server-example)
   - [Oracle Example](#oracle-example)
 - [📂 Project Structure](#-project-structure)
+- [📌 Available Methods in SQLPyHelper](#-available-methods-in-sqlpyhelper)
 - [🌍 Contributing](#-contributing)
 - [☕ Support the Project](#-support-the-project)
 
 ---
 
-## 🚀 Features
-- **Unified Interface** for multiple databases  
-- **Connection pooling support** for PostgreSQL  
-- **Bulk insertion & dynamic table creation**  
-- **Automated logging & query execution**  
-- **CSV export & backup functionality**  
+## 🚀 Features in v0.1.3
+✅ Unified connection pooling for multiple databases. 
+✅ Automatic reconnection for lost connections. 
+✅ Transaction support (BEGIN, ROLLBACK, COMMIT). 
+✅ Secure parameterized queries to prevent SQL injection. 
+✅ Bulk insertion & dynamic table creation. 
+✅ Logging & error handling for better debugging. 
+✅ CSV export & database backups.
 
 ---
 ## 📦 Installation
@@ -73,7 +76,7 @@ pip install sqlpyhelper
 ```
 📌 Package on PyPI: [SQLPyHelper on PyPI](https://pypi.org/project/SQLPyHelper/)
 
-Or, if working from source:
+For local development:
 ```sh
 git clone https://github.com/adebayopeter/sqlpyhelper.git
 cd sqlpyhelper
@@ -110,62 +113,46 @@ database = os.getenv("DB_NAME")
 ```
 ---
 ## 🛠 Usage Examples
-### SQLite Example
+### Initialize SQLPyHelper
 ```pycon
 from sqlpyhelper.db_helper import SQLPyHelper
-
-db = SQLPyHelper()
+db = SQLPyHelper()  # Auto-detects database type based on `DB_TYPE`
+```
+### SQLite Example
+```pycon
 db.execute_query("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT)")
 db.execute_query("INSERT INTO users (name) VALUES (?)", ("Alice",))
-db.execute_query("SELECT * FROM users")
-print(db.fetch_all())
+print(db.fetch_all()) # Expected Output: [(1, 'Alice')]
 db.close()
 ```
 ### PostgreSQL Example
 ```pycon
-db = SQLPyHelper()
-db.execute_query("CREATE TABLE IF NOT EXISTS employees (id SERIAL PRIMARY KEY, name VARCHAR(100))")
-db.execute_query("INSERT INTO employees (name) VALUES (%s)", ("Charlie",))
-db.execute_query("SELECT * FROM employees")
-print(db.fetch_all())
-db.close()
+db.execute_query("CREATE TABLE customers (id SERIAL PRIMARY KEY, name TEXT)")
+db.execute_query("INSERT INTO customers (name) VALUES (%s)", ("Bob",))
+db.begin_transaction()
+db.execute_query("DELETE FROM customers WHERE name=%s", ("Bob",))
+db.rollback_transaction()  # Undo delete
 ```
 ### MySQL Example
-```pycon
-db = SQLPyHelper()
-db.execute_query("CREATE TABLE IF NOT EXISTS customers (id INT PRIMARY KEY AUTO_INCREMENT, name VARCHAR(100))")
-db.execute_query("INSERT INTO customers (name) VALUES (%s)", ("David",))
-db.execute_query("SELECT * FROM customers")
-print(db.fetch_all())
-db.close()
-```
-```pycon
-db = SQLPyHelper()
-
-# Fetch rows where customer_id = 3
-customers = db.fetch_by_param("customers", "id", 3)
-print(customers)
-
+```pycon 
+db.execute_query("CREATE TABLE users (id INT PRIMARY KEY, name VARCHAR(100))")
+db.execute_query("INSERT INTO users (id, name) VALUES (%s, %s)", (1, "Alice"))
+print(db.fetch_by_param("users", "id", 1))  # Expected Output: [(1, 'Alice')]
 db.close()
 ```
-
 ### SQL Server Example
 ```pycon
-db = SQLPyHelper()
-db.execute_query("CREATE TABLE IF NOT EXISTS orders (id INT PRIMARY KEY, product VARCHAR(100))")
-db.execute_query("INSERT INTO orders (id, product) VALUES (?, ?)", (1, "Laptop"))
-db.execute_query("SELECT * FROM orders")
-print(db.fetch_all())
-db.close()
+db.execute_query("CREATE TABLE orders (order_id INT PRIMARY KEY, item NVARCHAR(100))")
+db.insert_bulk("orders", [{"order_id": 1, "item": "Laptop"}, {"order_id": 2, "item": "Mouse"}])
+db.backup_table("orders", "orders_backup.csv")  # Export data to CSV
 ```
 ### Oracle Example
 ```pycon
-db = SQLPyHelper()
 db.execute_query("CREATE TABLE employees (id NUMBER PRIMARY KEY, name VARCHAR2(100))")
-db.execute_query("INSERT INTO employees (id, name) VALUES (:1, :2)", (1, "Emily"))
-db.execute_query("SELECT * FROM employees")
-print(db.fetch_all())
-db.close()
+db.execute_query("INSERT INTO employees (id, name) VALUES (:1, :2)", (1, "Charlie"))
+db.setup_connection_pool(min_conn=2, max_conn=10)  # Enable pooling for better performance
+conn = db.get_connection_from_pool()
+db.return_connection_to_pool(conn)
 ```
 
 ## 📂 Project Structure
@@ -182,6 +169,24 @@ db.close()
 ├─ README.md
 └─ requirements.txt
 ```
+---
+## 📌 Available Methods in SQLPyHelper
+
+| Method | Description |
+|--------|-------------|
+| `execute_query(query, params=None)` | Executes a SQL query with optional parameters. |
+| `fetch_one()` | Retrieves a **single row** from query results. |
+| `fetch_all()` | Retrieves **all rows** from query results. |
+| `fetch_by_param(table, column, value)` | Fetches **rows dynamically** based on a given parameter. |
+| `create_table(table_name, columns_dict)` | Creates a table dynamically with a dictionary format. |
+| `insert_bulk(table, data_list)` | Inserts **multiple rows at once** efficiently. |
+| `backup_table(table, backup_file.csv)` | Exports table data to **CSV format**. |
+| `setup_connection_pool()` | Initializes **database connection pooling**. |
+| `get_connection_from_pool()` | Fetches a connection from the pool. |
+| `return_connection_to_pool(conn)` | Returns connection back to pool. |
+| `begin_transaction()` | Begins an **explicit transaction**. |
+| `rollback_transaction()` | Rolls back **uncommitted transactions**. |
+| `close()` | Closes the database connection safely. |
 
 ---
 ## 🌍 Contributing

{sqlpyhelper-0.1.2 → sqlpyhelper-0.1.3}/README.md

@@ -1,6 +1,6 @@
-# 📌 SQLPyHelper
+# 📌 SQLPyHelper v.0.1.3 🚀
 
-A Python library for simplified database interactions across **SQLite, PostgreSQL, MySQL, SQL Server, and Oracle**. This open-source package provides an intuitive API for handling database operations efficiently.
+A Python library for simplified database interactions across **SQLite, PostgreSQL, MySQL, SQL Server, and Oracle**. SQLPyHelper provides an intuitive API for handling queries, connection pooling, transactions, logging, and backups efficiently.
 
 ## 📖 Table of Contents
 - [🚀 Features](#-features)
@@ -13,17 +13,20 @@ A Python library for simplified database interactions across **SQLite, PostgreSQ
   - [SQL Server Example](#sql-server-example)
   - [Oracle Example](#oracle-example)
 - [📂 Project Structure](#-project-structure)
+- [📌 Available Methods in SQLPyHelper](#-available-methods-in-sqlpyhelper)
 - [🌍 Contributing](#-contributing)
 - [☕ Support the Project](#-support-the-project)
 
 ---
 
-## 🚀 Features
-- **Unified Interface** for multiple databases  
-- **Connection pooling support** for PostgreSQL  
-- **Bulk insertion & dynamic table creation**  
-- **Automated logging & query execution**  
-- **CSV export & backup functionality**  
+## 🚀 Features in v0.1.3
+✅ Unified connection pooling for multiple databases. 
+✅ Automatic reconnection for lost connections. 
+✅ Transaction support (BEGIN, ROLLBACK, COMMIT). 
+✅ Secure parameterized queries to prevent SQL injection. 
+✅ Bulk insertion & dynamic table creation. 
+✅ Logging & error handling for better debugging. 
+✅ CSV export & database backups.
 
 ---
 ## 📦 Installation
@@ -33,7 +36,7 @@ pip install sqlpyhelper
 ```
 📌 Package on PyPI: [SQLPyHelper on PyPI](https://pypi.org/project/SQLPyHelper/)
 
-Or, if working from source:
+For local development:
 ```sh
 git clone https://github.com/adebayopeter/sqlpyhelper.git
 cd sqlpyhelper
@@ -70,62 +73,46 @@ database = os.getenv("DB_NAME")
 ```
 ---
 ## 🛠 Usage Examples
-### SQLite Example
+### Initialize SQLPyHelper
 ```pycon
 from sqlpyhelper.db_helper import SQLPyHelper
-
-db = SQLPyHelper()
+db = SQLPyHelper()  # Auto-detects database type based on `DB_TYPE`
+```
+### SQLite Example
+```pycon
 db.execute_query("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT)")
 db.execute_query("INSERT INTO users (name) VALUES (?)", ("Alice",))
-db.execute_query("SELECT * FROM users")
-print(db.fetch_all())
+print(db.fetch_all()) # Expected Output: [(1, 'Alice')]
 db.close()
 ```
 ### PostgreSQL Example
 ```pycon
-db = SQLPyHelper()
-db.execute_query("CREATE TABLE IF NOT EXISTS employees (id SERIAL PRIMARY KEY, name VARCHAR(100))")
-db.execute_query("INSERT INTO employees (name) VALUES (%s)", ("Charlie",))
-db.execute_query("SELECT * FROM employees")
-print(db.fetch_all())
-db.close()
+db.execute_query("CREATE TABLE customers (id SERIAL PRIMARY KEY, name TEXT)")
+db.execute_query("INSERT INTO customers (name) VALUES (%s)", ("Bob",))
+db.begin_transaction()
+db.execute_query("DELETE FROM customers WHERE name=%s", ("Bob",))
+db.rollback_transaction()  # Undo delete
 ```
 ### MySQL Example
-```pycon
-db = SQLPyHelper()
-db.execute_query("CREATE TABLE IF NOT EXISTS customers (id INT PRIMARY KEY AUTO_INCREMENT, name VARCHAR(100))")
-db.execute_query("INSERT INTO customers (name) VALUES (%s)", ("David",))
-db.execute_query("SELECT * FROM customers")
-print(db.fetch_all())
-db.close()
-```
-```pycon
-db = SQLPyHelper()
-
-# Fetch rows where customer_id = 3
-customers = db.fetch_by_param("customers", "id", 3)
-print(customers)
-
+```pycon 
+db.execute_query("CREATE TABLE users (id INT PRIMARY KEY, name VARCHAR(100))")
+db.execute_query("INSERT INTO users (id, name) VALUES (%s, %s)", (1, "Alice"))
+print(db.fetch_by_param("users", "id", 1))  # Expected Output: [(1, 'Alice')]
 db.close()
 ```
-
 ### SQL Server Example
 ```pycon
-db = SQLPyHelper()
-db.execute_query("CREATE TABLE IF NOT EXISTS orders (id INT PRIMARY KEY, product VARCHAR(100))")
-db.execute_query("INSERT INTO orders (id, product) VALUES (?, ?)", (1, "Laptop"))
-db.execute_query("SELECT * FROM orders")
-print(db.fetch_all())
-db.close()
+db.execute_query("CREATE TABLE orders (order_id INT PRIMARY KEY, item NVARCHAR(100))")
+db.insert_bulk("orders", [{"order_id": 1, "item": "Laptop"}, {"order_id": 2, "item": "Mouse"}])
+db.backup_table("orders", "orders_backup.csv")  # Export data to CSV
 ```
 ### Oracle Example
 ```pycon
-db = SQLPyHelper()
 db.execute_query("CREATE TABLE employees (id NUMBER PRIMARY KEY, name VARCHAR2(100))")
-db.execute_query("INSERT INTO employees (id, name) VALUES (:1, :2)", (1, "Emily"))
-db.execute_query("SELECT * FROM employees")
-print(db.fetch_all())
-db.close()
+db.execute_query("INSERT INTO employees (id, name) VALUES (:1, :2)", (1, "Charlie"))
+db.setup_connection_pool(min_conn=2, max_conn=10)  # Enable pooling for better performance
+conn = db.get_connection_from_pool()
+db.return_connection_to_pool(conn)
 ```
 
 ## 📂 Project Structure
@@ -142,6 +129,24 @@ db.close()
 ├─ README.md
 └─ requirements.txt
 ```
+---
+## 📌 Available Methods in SQLPyHelper
+
+| Method | Description |
+|--------|-------------|
+| `execute_query(query, params=None)` | Executes a SQL query with optional parameters. |
+| `fetch_one()` | Retrieves a **single row** from query results. |
+| `fetch_all()` | Retrieves **all rows** from query results. |
+| `fetch_by_param(table, column, value)` | Fetches **rows dynamically** based on a given parameter. |
+| `create_table(table_name, columns_dict)` | Creates a table dynamically with a dictionary format. |
+| `insert_bulk(table, data_list)` | Inserts **multiple rows at once** efficiently. |
+| `backup_table(table, backup_file.csv)` | Exports table data to **CSV format**. |
+| `setup_connection_pool()` | Initializes **database connection pooling**. |
+| `get_connection_from_pool()` | Fetches a connection from the pool. |
+| `return_connection_to_pool(conn)` | Returns connection back to pool. |
+| `begin_transaction()` | Begins an **explicit transaction**. |
+| `rollback_transaction()` | Rolls back **uncommitted transactions**. |
+| `close()` | Closes the database connection safely. |
 
 ---
 ## 🌍 Contributing

{sqlpyhelper-0.1.2 → sqlpyhelper-0.1.3}/SQLPyHelper.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SQLPyHelper
-Version: 0.1.2
+Version: 0.1.3
 Summary: A simple SQL database helper package for Python.
 Author: Adebayo Olaonipekun
 Author-email: pekunmi@live.com
@@ -38,9 +38,9 @@ Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 
-# 📌 SQLPyHelper
+# 📌 SQLPyHelper v.0.1.3 🚀
 
-A Python library for simplified database interactions across **SQLite, PostgreSQL, MySQL, SQL Server, and Oracle**. This open-source package provides an intuitive API for handling database operations efficiently.
+A Python library for simplified database interactions across **SQLite, PostgreSQL, MySQL, SQL Server, and Oracle**. SQLPyHelper provides an intuitive API for handling queries, connection pooling, transactions, logging, and backups efficiently.
 
 ## 📖 Table of Contents
 - [🚀 Features](#-features)
@@ -53,17 +53,20 @@ A Python library for simplified database interactions across **SQLite, PostgreSQ
   - [SQL Server Example](#sql-server-example)
   - [Oracle Example](#oracle-example)
 - [📂 Project Structure](#-project-structure)
+- [📌 Available Methods in SQLPyHelper](#-available-methods-in-sqlpyhelper)
 - [🌍 Contributing](#-contributing)
 - [☕ Support the Project](#-support-the-project)
 
 ---
 
-## 🚀 Features
-- **Unified Interface** for multiple databases  
-- **Connection pooling support** for PostgreSQL  
-- **Bulk insertion & dynamic table creation**  
-- **Automated logging & query execution**  
-- **CSV export & backup functionality**  
+## 🚀 Features in v0.1.3
+✅ Unified connection pooling for multiple databases. 
+✅ Automatic reconnection for lost connections. 
+✅ Transaction support (BEGIN, ROLLBACK, COMMIT). 
+✅ Secure parameterized queries to prevent SQL injection. 
+✅ Bulk insertion & dynamic table creation. 
+✅ Logging & error handling for better debugging. 
+✅ CSV export & database backups.
 
 ---
 ## 📦 Installation
@@ -73,7 +76,7 @@ pip install sqlpyhelper
 ```
 📌 Package on PyPI: [SQLPyHelper on PyPI](https://pypi.org/project/SQLPyHelper/)
 
-Or, if working from source:
+For local development:
 ```sh
 git clone https://github.com/adebayopeter/sqlpyhelper.git
 cd sqlpyhelper
@@ -110,62 +113,46 @@ database = os.getenv("DB_NAME")
 ```
 ---
 ## 🛠 Usage Examples
-### SQLite Example
+### Initialize SQLPyHelper
 ```pycon
 from sqlpyhelper.db_helper import SQLPyHelper
-
-db = SQLPyHelper()
+db = SQLPyHelper()  # Auto-detects database type based on `DB_TYPE`
+```
+### SQLite Example
+```pycon
 db.execute_query("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT)")
 db.execute_query("INSERT INTO users (name) VALUES (?)", ("Alice",))
-db.execute_query("SELECT * FROM users")
-print(db.fetch_all())
+print(db.fetch_all()) # Expected Output: [(1, 'Alice')]
 db.close()
 ```
 ### PostgreSQL Example
 ```pycon
-db = SQLPyHelper()
-db.execute_query("CREATE TABLE IF NOT EXISTS employees (id SERIAL PRIMARY KEY, name VARCHAR(100))")
-db.execute_query("INSERT INTO employees (name) VALUES (%s)", ("Charlie",))
-db.execute_query("SELECT * FROM employees")
-print(db.fetch_all())
-db.close()
+db.execute_query("CREATE TABLE customers (id SERIAL PRIMARY KEY, name TEXT)")
+db.execute_query("INSERT INTO customers (name) VALUES (%s)", ("Bob",))
+db.begin_transaction()
+db.execute_query("DELETE FROM customers WHERE name=%s", ("Bob",))
+db.rollback_transaction()  # Undo delete
 ```
 ### MySQL Example
-```pycon
-db = SQLPyHelper()
-db.execute_query("CREATE TABLE IF NOT EXISTS customers (id INT PRIMARY KEY AUTO_INCREMENT, name VARCHAR(100))")
-db.execute_query("INSERT INTO customers (name) VALUES (%s)", ("David",))
-db.execute_query("SELECT * FROM customers")
-print(db.fetch_all())
-db.close()
-```
-```pycon
-db = SQLPyHelper()
-
-# Fetch rows where customer_id = 3
-customers = db.fetch_by_param("customers", "id", 3)
-print(customers)
-
+```pycon 
+db.execute_query("CREATE TABLE users (id INT PRIMARY KEY, name VARCHAR(100))")
+db.execute_query("INSERT INTO users (id, name) VALUES (%s, %s)", (1, "Alice"))
+print(db.fetch_by_param("users", "id", 1))  # Expected Output: [(1, 'Alice')]
 db.close()
 ```
-
 ### SQL Server Example
 ```pycon
-db = SQLPyHelper()
-db.execute_query("CREATE TABLE IF NOT EXISTS orders (id INT PRIMARY KEY, product VARCHAR(100))")
-db.execute_query("INSERT INTO orders (id, product) VALUES (?, ?)", (1, "Laptop"))
-db.execute_query("SELECT * FROM orders")
-print(db.fetch_all())
-db.close()
+db.execute_query("CREATE TABLE orders (order_id INT PRIMARY KEY, item NVARCHAR(100))")
+db.insert_bulk("orders", [{"order_id": 1, "item": "Laptop"}, {"order_id": 2, "item": "Mouse"}])
+db.backup_table("orders", "orders_backup.csv")  # Export data to CSV
 ```
 ### Oracle Example
 ```pycon
-db = SQLPyHelper()
 db.execute_query("CREATE TABLE employees (id NUMBER PRIMARY KEY, name VARCHAR2(100))")
-db.execute_query("INSERT INTO employees (id, name) VALUES (:1, :2)", (1, "Emily"))
-db.execute_query("SELECT * FROM employees")
-print(db.fetch_all())
-db.close()
+db.execute_query("INSERT INTO employees (id, name) VALUES (:1, :2)", (1, "Charlie"))
+db.setup_connection_pool(min_conn=2, max_conn=10)  # Enable pooling for better performance
+conn = db.get_connection_from_pool()
+db.return_connection_to_pool(conn)
 ```
 
 ## 📂 Project Structure
@@ -182,6 +169,24 @@ db.close()
 ├─ README.md
 └─ requirements.txt
 ```
+---
+## 📌 Available Methods in SQLPyHelper
+
+| Method | Description |
+|--------|-------------|
+| `execute_query(query, params=None)` | Executes a SQL query with optional parameters. |
+| `fetch_one()` | Retrieves a **single row** from query results. |
+| `fetch_all()` | Retrieves **all rows** from query results. |
+| `fetch_by_param(table, column, value)` | Fetches **rows dynamically** based on a given parameter. |
+| `create_table(table_name, columns_dict)` | Creates a table dynamically with a dictionary format. |
+| `insert_bulk(table, data_list)` | Inserts **multiple rows at once** efficiently. |
+| `backup_table(table, backup_file.csv)` | Exports table data to **CSV format**. |
+| `setup_connection_pool()` | Initializes **database connection pooling**. |
+| `get_connection_from_pool()` | Fetches a connection from the pool. |
+| `return_connection_to_pool(conn)` | Returns connection back to pool. |
+| `begin_transaction()` | Begins an **explicit transaction**. |
+| `rollback_transaction()` | Rolls back **uncommitted transactions**. |
+| `close()` | Closes the database connection safely. |
 
 ---
 ## 🌍 Contributing

{sqlpyhelper-0.1.2 → sqlpyhelper-0.1.3}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as f:
 
 setup(
     name='SQLPyHelper',
-    version='0.1.2',
+    version='0.1.3',
     description='A simple SQL database helper package for Python.',
     long_description=long_description,
     long_description_content_type="text/markdown",

{sqlpyhelper-0.1.2 → sqlpyhelper-0.1.3}/sqlpyhelper/__init__.py

@@ -1,2 +1,2 @@
 # Match the version in setup.py
-__version__ = "0.1.2"
+__version__ = "0.1.3"

sqlpyhelper-0.1.3/sqlpyhelper/db_helper.py

@@ -0,0 +1,209 @@
+import csv
+from dotenv import load_dotenv
+import os
+
+load_dotenv()  # Load environment variables from .env file
+
+
+def log_query(query):
+    """Logs queries for debugging purposes."""
+    with open("query_log.txt", "a") as f:
+        f.write(query + "\n")
+
+
+class SQLPyHelper:
+    def __init__(self):
+        self.db_type = os.getenv("DB_TYPE").lower()
+        self.host = os.getenv("DB_HOST")
+        self.user = os.getenv("DB_USER")
+        self.password = os.getenv("DB_PASSWORD")
+        self.database = os.getenv("DB_NAME")
+        self.driver = os.getenv("DB_DRIVER")
+        self.oracle_sid = os.getenv("ORACLE_SID")
+        self.pool = None
+
+        if self.db_type == "sqlite":
+            import sqlite3
+            self.connection = sqlite3.connect(self.database)
+        elif self.db_type == "postgres":
+            import psycopg2
+            self.connection = psycopg2.connect(host=self.host, user=self.user,
+                                               password=self.password, dbname=self.database)
+        elif self.db_type == "mysql":
+            import mysql.connector
+            self.connection = mysql.connector.connect(host=self.host, user=self.user,
+                                                      password=self.password, database=self.database)
+        elif self.db_type == "sqlserver":
+            import pyodbc
+            self.connection = pyodbc.connect(f"DRIVER={self.driver};SERVER={self.host};DATABASE={self.database};"
+                                             f"UID={self.user};PWD={self.password}")
+        elif self.db_type == "oracle":
+            import cx_Oracle
+            oracle_port = os.getenv("ORACLE_DB_PORT", "1521")  # Default to 1521 if not set
+            dsn = cx_Oracle.makedsn(self.host, oracle_port, self.oracle_sid)
+            self.connection = cx_Oracle.connect(self.user, self.password, dsn)
+        else:
+            raise ValueError("Unsupported database type")
+
+        self.cursor = self.connection.cursor()
+
+    def execute_query(self, query, params=None):
+        """Executes a query with optional parameters"""
+        try:
+            if params:
+                self.cursor.execute(query, params)
+            else:
+                self.cursor.execute(query)
+            self.connection.commit()
+        except Exception as e:
+            if "server has gone away" in str(e):  # Example check for MySQL lost connection
+                self.reconnect()
+                self.cursor.execute(query, params)
+                self.connection.commit()
+            else:
+                print(f"Error executing query: {e}")
+
+    def fetch_one(self):
+        """Fetches a single row"""
+        try:
+            return self.cursor.fetchone()
+        except Exception as e:
+            print(f"Error fetching row: {e}")
+            return None
+
+    def fetch_all(self):
+        """Fetches all rows from the last executed query"""
+        try:
+            return self.cursor.fetchall()
+        except Exception as e:
+            print(f"Error fetching rows: {e}")
+            return None
+
+    def fetch_by_param(self, table_name, column_name, value):
+        try:
+            query = f"SELECT * FROM {table_name} WHERE {column_name} = %s"
+            self.cursor.execute(query, (value,))
+            return self.cursor.fetchall()
+        except Exception as e:
+            print(f"Error fetching row(s): {e}")
+            return None
+
+    def close(self):
+        """Closes the connection"""
+        try:
+            self.cursor.close()
+            self.connection.close()
+        except Exception as e:
+            print(f"Error closing connection: {e}")
+            return None
+
+    def create_table(self, table_name, columns):
+        """
+        Creates a table dynamically using a dictionary format.
+        Example:
+        columns = {'id': 'INTEGER PRIMARY KEY', 'name': 'TEXT', 'age': 'INTEGER'}
+        """
+        try:
+            column_defs = ", ".join(f"{col} {dtype}" for col, dtype in columns.items())
+            query = f"CREATE TABLE {table_name} ({column_defs})"
+            self.execute_query(query)
+        except Exception as e:
+            print(f"Error creating table: {e}")
+            return None
+
+    def insert_bulk(self, table_name, data):
+        """
+        Inserts multiple rows at once.
+        Example:
+        data = [{'id': 1, 'name': 'Alice'}, {'id': 2, 'name': 'Bob'}]
+        """
+        try:
+            columns = ", ".join(data[0].keys())  # Extract column names
+            placeholders = ", ".join(["%s" for _ in data[0].keys()])  # Generate placeholders
+            query = f"INSERT INTO {table_name} ({columns}) VALUES ({placeholders})"
+            values = [tuple(row.values()) for row in data]
+            self.cursor.executemany(query, values)
+            self.connection.commit()
+
+        except Exception as e:
+            print(f"Error inserting bulk rows: {e}")
+            return None
+
+    def backup_table(self, table_name, backup_file):
+        """
+        Exports table data into a CSV file.
+        Example:
+        backup_table('users', 'users_backup.csv')
+        """
+        try:
+            query = f"SELECT * FROM {table_name}"
+            self.execute_query(query)
+            rows = self.fetch_all()
+
+            with open(backup_file, mode="w", newline="") as file:
+                writer = csv.writer(file)
+                writer.writerow([desc[0] for desc in self.cursor.description])  # Column headers
+                writer.writerows(rows)
+        except Exception as e:
+            print(f"Error backing up table: {e}")
+            return None
+
+    def setup_connection_pool(self, min_conn=1, max_conn=5, pool_size=5):
+        """Sets up connection pooling based on the database type"""
+        try:
+            if self.db_type == "postgres":
+                from psycopg2 import pool
+                self.pool = pool.SimpleConnectionPool(min_conn, max_conn,
+                                                      host=self.host, user=self.user,
+                                                      password=self.password, dbname=self.database)
+
+            elif self.db_type == "mysql":
+                import mysql.connector.pooling
+                self.pool = mysql.connector.pooling.MySQLConnectionPool(pool_name="mypool",
+                                                                        pool_size=pool_size, host=self.host,
+                                                                        user=self.user, password=self.password,
+                                                                        database=self.database)
+
+            elif self.db_type == "sqlserver":
+                import pyodbc
+                self.pool = [
+                    pyodbc.connect(f"DRIVER={self.driver};SERVER={self.host};DATABASE={self.database};"
+                                   f"UID={self.user};PWD={self.password};ConnectionPooling=Yes")
+                    for _ in range(pool_size)
+                ]
+
+            elif self.db_type == "oracle":
+                import cx_Oracle
+                oracle_port = os.getenv("ORACLE_DB_PORT", "1521")  # Default Oracle port
+                dsn = cx_Oracle.makedsn(self.host, oracle_port, self.oracle_sid)
+                self.pool = cx_Oracle.SessionPool(user=self.user, password=self.password, dsn=dsn,
+                                                  min=min_conn, max=max_conn, increment=1, threaded=True)
+
+            else:
+                raise ValueError(f"Connection pooling not supported for {self.db_type}")
+        except Exception as e:
+            print(f"⚠️ Error setting up connection pool: {e}")
+            self.pool = None  # Prevent broken pool usage
+
+    def get_connection_from_pool(self):
+        """Fetches a connection from the pool."""
+        return self.pool.get_connection()
+
+    def return_connection_to_pool(self):
+        """Returns a connection back to the pool."""
+        self.connection.close()
+
+    def reconnect(self):
+        """Reconnects to the database if connection is lost"""
+        try:
+            self.connection.close()  # Close existing connection
+            self.__init__()  # Reinitialize the connection
+            print("Database reconnected successfully.")
+        except Exception as e:
+            print(f"Error during reconnection: {e}")
+
+    def begin_transaction(self):
+        self.execute_query("START TRANSACTION")
+
+    def rollback_transaction(self):
+        self.execute_query("ROLLBACK")

sqlpyhelper-0.1.3/test/test_sqlpyhelper.py

@@ -0,0 +1,86 @@
+import pytest
+from sqlpyhelper.db_helper import SQLPyHelper
+import os
+
+
+# Connection test
+@pytest.fixture
+def db():
+    """Fixture to initialize and return a database helper instance based on DB_TYPE."""
+    db_type = os.getenv("DB_TYPE", "mysql")  # Default to MySQL if not set
+    os.environ["DB_TYPE"] = db_type  # Ensure correct DB type is used
+    db_instance = SQLPyHelper()
+    yield db_instance
+    db_instance.close()  # Cleanup after tests
+
+
+@pytest.mark.skipif(os.getenv("DB_TYPE") != "mysql", reason="Skipping non-MySQL tests")
+def test_connection(db):
+    """Ensure MySQL connects successfully."""
+    assert db.connection is not None, "MySQL connection failed!"
+
+
+@pytest.mark.skipif(os.getenv("DB_TYPE") != "mysql", reason="Skipping non-MySQL tests")
+def test_fetch_all(db):
+    """Ensure fetch_all retrieves multiple rows in MySQL."""
+    db.execute_query("INSERT INTO customers (name) VALUES ('Sade'), ('Rita')")
+    db.execute_query("SELECT * FROM customers")
+    result = db.fetch_all()
+    assert len(result) >= 2, "fetch_all() failed to return expected results!"
+
+
+# Query Execution & Fetching
+@pytest.mark.parametrize("db_type,query", [
+    ("mysql", "CREATE TABLE test_user_tbl (id INT PRIMARY KEY, name VARCHAR(100))"),
+    # ("postgres", "CREATE TABLE test_user_tbl (id SERIAL PRIMARY KEY, name TEXT)"),
+    # ("sqlserver", "CREATE TABLE test_user_tbl (id INT PRIMARY KEY, name NVARCHAR(100))"),
+    # ("oracle", "CREATE TABLE test_user_tbl (id NUMBER PRIMARY KEY, name VARCHAR2(100))")
+])
+def test_query_execution(db_type, query):
+    """Test table creation syntax across database variants."""
+    os.environ["DB_TYPE"] = db_type
+    db = SQLPyHelper()
+    db.execute_query(query)
+    assert True  # If no errors, test passes
+    db.close()
+
+
+# Parameterized Query Tests
+# @pytest.mark.parametrize("db_type", ["mysql", "postgres", "sqlserver", "oracle"])
+@pytest.mark.parametrize("db_type", ["mysql"])
+def test_fetch_by_param(db_type):
+    """Test parameterized queries for different databases."""
+    os.environ["DB_TYPE"] = db_type
+    db = SQLPyHelper()
+
+    result = db.fetch_by_param("customers", "name", "David")
+    assert len(result) >= 1, f"Failed to fetch record for {db_type}"
+    db.close()
+
+
+# Connection Pooling Validation
+# @pytest.mark.parametrize("db_type", ["mysql", "postgres", "sqlserver", "oracle"])
+@pytest.mark.parametrize("db_type", ["mysql"])
+def test_connection_pooling(db_type):
+    """Test pooling setup for different databases."""
+    os.environ["DB_TYPE"] = db_type
+    db = SQLPyHelper()
+    db.setup_connection_pool()
+    conn = db.get_connection_from_pool()
+    assert conn is not None, f"Pooling failed for {db_type}"
+    db.return_connection_to_pool()
+    db.close()
+
+
+# Transaction Management
+def test_transaction_rollback(db):
+    """Verify rollback restores previous state."""
+    db.begin_transaction()
+    db.execute_query("INSERT INTO customers (name) VALUES ('Eve')")
+    db.rollback_transaction()
+    result = db.fetch_by_param("customers", "name", "Eve")
+    assert len(result) == 0, "Rollback did not revert changes!"
+
+
+# pytest test_sqlpyhelper.py
+

sqlpyhelper-0.1.2/sqlpyhelper/db_helper.py

@@ -1,135 +0,0 @@
-import csv
-from dotenv import load_dotenv
-import os
-
-load_dotenv()  # Load environment variables from .env file
-
-
-def log_query(query):
-    """Logs queries for debugging purposes."""
-    with open("query_log.txt", "a") as f:
-        f.write(query + "\n")
-
-
-class SQLPyHelper:
-    def __init__(self):
-        self.db_type = os.getenv("DB_TYPE").lower()
-        self.host = os.getenv("DB_HOST")
-        self.user = os.getenv("DB_USER")
-        self.password = os.getenv("DB_PASSWORD")
-        self.database = os.getenv("DB_NAME")
-        self.driver = os.getenv("DB_DRIVER")
-        self.oracle_sid = os.getenv("ORACLE_SID")
-        self.pool = None
-
-        if self.db_type == "sqlite":
-            import sqlite3
-            self.connection = sqlite3.connect(self.database)
-        elif self.db_type == "postgres":
-            import psycopg2
-            self.connection = psycopg2.connect(host=self.host, user=self.user,
-                                               password=self.password, dbname=self.database)
-        elif self.db_type == "mysql":
-            import mysql.connector
-            self.connection = mysql.connector.connect(host=self.host, user=self.user,
-                                                      password=self.password, database=self.database)
-        elif self.db_type == "sqlserver":
-            import pyodbc
-            self.connection = pyodbc.connect(f"DRIVER={self.driver};SERVER={self.host};DATABASE={self.database};"
-                                             f"UID={self.user};PWD={self.password}")
-        elif self.db_type == "oracle":
-            import cx_Oracle
-            oracle_port = os.getenv("ORACLE_DB_PORT", "1521")  # Default to 1521 if not set
-            dsn = cx_Oracle.makedsn(self.host, oracle_port, self.oracle_sid)
-            self.connection = cx_Oracle.connect(self.user, self.password, dsn)
-        else:
-            raise ValueError("Unsupported database type")
-
-        self.cursor = self.connection.cursor()
-
-    def execute_query(self, query, params=None):
-        """Executes a query with optional parameters"""
-        try:
-            if params:
-                self.cursor.execute(query, params)
-            else:
-                self.cursor.execute(query)
-            self.connection.commit()
-        except Exception as e:
-            print(f"Error executing query: {e}")
-
-    def fetch_one(self):
-        return self.cursor.fetchone()
-
-    def fetch_all(self):
-        """Fetches all rows from the last executed query"""
-        return self.cursor.fetchall()
-
-    def fetch_by_param(self, table_name, column_name, value):
-        query = f"SELECT * FROM {table_name} WHERE {column_name} = %s"
-        self.cursor.execute(query, (value,))
-        return self.cursor.fetchall()  # Fetch matching rows
-
-    def close(self):
-        """Closes the connection"""
-        self.cursor.close()
-        self.connection.close()
-
-    def create_table(self, table_name, columns):
-        """
-        Creates a table dynamically using a dictionary format.
-        Example:
-        columns = {'id': 'INTEGER PRIMARY KEY', 'name': 'TEXT', 'age': 'INTEGER'}
-        """
-        column_defs = ", ".join(f"{col} {dtype}" for col, dtype in columns.items())
-        query = f"CREATE TABLE {table_name} ({column_defs})"
-        self.execute_query(query)
-
-    def insert_bulk(self, table_name, data):
-        """
-        Inserts multiple rows at once.
-        Example:
-        data = [{'id': 1, 'name': 'Alice'}, {'id': 2, 'name': 'Bob'}]
-        """
-        columns = ", ".join(data[0].keys())  # Extract column names
-        placeholders = ", ".join(["%s" for _ in data[0].keys()])  # Generate placeholders
-        query = f"INSERT INTO {table_name} ({columns}) VALUES ({placeholders})"
-        values = [tuple(row.values()) for row in data]  # Convert dictionaries to tuples
-        self.cursor.executemany(query, values)
-        self.connection.commit()
-
-    def backup_table(self, table_name, backup_file):
-        """
-        Exports table data into a CSV file.
-        Example:
-        backup_table('users', 'users_backup.csv')
-        """
-        query = f"SELECT * FROM {table_name}"
-        self.execute_query(query)
-        rows = self.fetch_all()
-
-        with open(backup_file, mode="w", newline="") as file:
-            writer = csv.writer(file)
-            writer.writerow([desc[0] for desc in self.cursor.description])  # Column headers
-            writer.writerows(rows)
-
-    def setup_postgres_pool(self, min_conn=1, max_conn=5):
-        """
-        Creates a connection pool for PostgreSQL.
-        Example:
-        setup_postgres_pool(min_conn=2, max_conn=10)
-        """
-        from psycopg2 import pool
-        self.pool = pool.SimpleConnectionPool(min_conn, max_conn,
-                                              host=self.host,
-                                              user=self.user,
-                                              password=self.password,
-                                              dbname=self.database)
-
-    def get_connection_from_pool(self):
-        """Fetches a connection from the pool."""
-        return self.pool.getconn()
-
-    def return_connection_to_pool(self, conn):
-        """Returns a connection back to the pool."""
-        self.pool.putconn(conn)

sqlpyhelper-0.1.2/test/test_sqlpyhelper.py

@@ -1,71 +0,0 @@
-from sqlpyhelper.db_helper import SQLPyHelper
-
-
-# SQLite Test
-def test_sqlite():
-    print("Testing SQLite...")
-    db = SQLPyHelper()
-    db.execute_query("CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, name TEXT)")
-    db.execute_query("INSERT INTO users (name) VALUES (?)", ("Alice",))
-    db.execute_query("INSERT INTO users (name) VALUES (?)", ("Bob",))
-    db.execute_query("SELECT * FROM users")
-    results = db.fetch_all()
-    print("Results:", results)
-    db.close()
-
-
-# PostgreSQL Test (Ensure you have PostgreSQL running locally)
-def test_postgres():
-    print("Testing PostgreSQL...")
-    db = SQLPyHelper()
-    db.execute_query("CREATE TABLE IF NOT EXISTS employees (id SERIAL PRIMARY KEY, name VARCHAR(100))")
-    db.execute_query("INSERT INTO employees (name) VALUES (%s)", ("Charlie",))
-    db.execute_query("SELECT * FROM employees")
-    results = db.fetch_all()
-    print("Results:", results)
-    db.close()
-
-
-# MySQL Test (Ensure MySQL is running locally)
-def test_mysql():
-    print("Testing MySQL...")
-    db = SQLPyHelper()
-    db.execute_query("CREATE TABLE IF NOT EXISTS customers (id INT PRIMARY KEY AUTO_INCREMENT, name VARCHAR(100))")
-    db.execute_query("INSERT INTO customers (name) VALUES (%s)", ("Joe",))
-    db.execute_query("SELECT * FROM customers")
-    results = db.fetch_all()
-    print("Results:", results)
-    db.close()
-
-
-# SQL Server Test (Requires ODBC Driver for SQL Server)
-def test_sqlserver():
-    print("Testing SQL Server...")
-    db = SQLPyHelper()
-    db.execute_query("CREATE TABLE IF NOT EXISTS orders (id INT PRIMARY KEY, product VARCHAR(100))")
-    db.execute_query("INSERT INTO orders (id, product) VALUES (?, ?)", (1, "Laptop"))
-    db.execute_query("SELECT * FROM orders")
-    results = db.fetch_all()
-    print("Results:", results)
-    db.close()
-
-
-# Oracle Test (Ensure Oracle is installed & running)
-def test_oracle():
-    print("Testing Oracle...")
-    db = SQLPyHelper()
-    db.execute_query("CREATE TABLE employees (id NUMBER PRIMARY KEY, name VARCHAR2(100))")
-    db.execute_query("INSERT INTO employees (id, name) VALUES (:1, :2)", (1, "Emily"))
-    db.execute_query("SELECT * FROM employees")
-    results = db.fetch_all()
-    print("Results:", results)
-    db.close()
-
-
-# Run Tests
-if __name__ == "__main__":
-    # test_sqlite()
-    # test_postgres()
-    test_mysql()
-    # test_sqlserver()
-    # test_oracle()