SQLPyHelper 0.1.1__tar.gz → 0.1.3__tar.gz

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

@@ -1,12 +1,15 @@
 Metadata-Version: 2.4
 Name: SQLPyHelper
-Version: 0.1.1
+Version: 0.1.3
 Summary: A simple SQL database helper package for Python.
 Author: Adebayo Olaonipekun
 Author-email: pekunmi@live.com
 Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Database :: Database Engines/Servers
 Classifier: Operating System :: OS Independent
+Classifier: License :: OSI Approved :: MIT License
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
@@ -15,19 +18,29 @@ Requires-Dist: mysql-connector-python
 Requires-Dist: pyodbc
 Requires-Dist: cx_Oracle
 Requires-Dist: python-dotenv
+Provides-Extra: mysql
+Requires-Dist: mysql-connector-python; extra == "mysql"
+Provides-Extra: postgres
+Requires-Dist: psycopg2; extra == "postgres"
+Provides-Extra: oracle
+Requires-Dist: cx_Oracle; extra == "oracle"
+Provides-Extra: sqlserver
+Requires-Dist: pyodbc; extra == "sqlserver"
+Provides-Extra: sqlite
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: license-file
+Dynamic: provides-extra
 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)
@@ -40,24 +53,30 @@ 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
+#### Install via PyPI:
 ```sh
 pip install sqlpyhelper
 ```
-Or, if working from source:
+📌 Package on PyPI: [SQLPyHelper on PyPI](https://pypi.org/project/SQLPyHelper/)
+
+For local development:
 ```sh
 git clone https://github.com/adebayopeter/sqlpyhelper.git
 cd sqlpyhelper
@@ -75,11 +94,10 @@ DB_TYPE=postgres
 DB_HOST=localhost
 DB_USER=your_user
 DB_PASSWORD=your_secure_password
-DB_NAME=test_db
-DB_PORT=5432
+DB_NAME=database_name
 DB_DRIVER={ODBC Driver 17 for SQL Server}
 ORACLE_SID=XE
-ORACLE_PORT=1521
+ORACLE_DB_PORT=1521
 ```
 ### Loading `.env` in Code
 ```pycon
@@ -95,52 +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())
+```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
@@ -157,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.3/README.md

@@ -0,0 +1,176 @@
+# 📌 SQLPyHelper v.0.1.3 🚀
+
+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)
+- [📦 Installation](#-installation)
+- [⚙️ Setup Using `.env`](#️-setup-using-env)
+- [🛠 Usage Examples](#-usage-examples)
+  - [SQLite Example](#sqlite-example)
+  - [PostgreSQL Example](#postgresql-example)
+  - [MySQL Example](#mysql-example)
+  - [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 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
+#### Install via PyPI:
+```sh
+pip install sqlpyhelper
+```
+📌 Package on PyPI: [SQLPyHelper on PyPI](https://pypi.org/project/SQLPyHelper/)
+
+For local development:
+```sh
+git clone https://github.com/adebayopeter/sqlpyhelper.git
+cd sqlpyhelper
+pip install -r requirements.txt
+```
+
+---
+
+## ⚙️ Setup Using `.env`
+Create a `.env` file in your project root to manage database configurations securely by renaming `.env_example`.
+
+```sh
+# .env_example (Rename to .env)
+DB_TYPE=postgres
+DB_HOST=localhost
+DB_USER=your_user
+DB_PASSWORD=your_secure_password
+DB_NAME=database_name
+DB_DRIVER={ODBC Driver 17 for SQL Server}
+ORACLE_SID=XE
+ORACLE_DB_PORT=1521
+```
+### Loading `.env` in Code
+```pycon
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+db_type = os.getenv("DB_TYPE")
+host = os.getenv("DB_HOST")
+user = os.getenv("DB_USER")
+password = os.getenv("DB_PASSWORD")
+database = os.getenv("DB_NAME")
+```
+---
+## 🛠 Usage Examples
+### Initialize SQLPyHelper
+```pycon
+from sqlpyhelper.db_helper import 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",))
+print(db.fetch_all()) # Expected Output: [(1, 'Alice')]
+db.close()
+```
+### PostgreSQL Example
+```pycon
+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.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.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.execute_query("CREATE TABLE employees (id NUMBER PRIMARY KEY, name VARCHAR2(100))")
+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
+```
+📦 SQLPyHelper/
+├─ sqlpyhelper/
+│  ├─ __init__.py
+│  └─ db_helper.py
+├─ tests/
+│  └─ test_sqlpyhelper.py
+├─ .env_example
+├─ .gitignore
+├─ setup.py
+├─ 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
+We welcome contributions from the **open-source community**! Follow these steps to contribute:
+
+1. Fork the repo: [SQLPyHelper GitHub Repository](https://github.com/adebayopeter/sqlpyhelper)
+2. Clone your fork:
+   ```sh
+   git clone https://github.com/adebayopeter/sqlpyhelper.git
+   ```
+3. Create a new branch:
+   ```sh
+   git checkout -b feature-new-functionality
+   ```
+4. Make changes, commit, and push:
+   ```sh
+   git commit -m "Added new feature"
+   git push origin feature-new-functionality
+   ```
+5. Submit a Pull Request!
+
+---
+## ☕ Support the Project
+
+If you find SQLPyHelper useful, consider buying me a coffee to support continued development! 
+Donate Here: [PayPal](https://paypal.me/adebayopeter?country.x=GB&locale.x=en_GB)
+---

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

@@ -1,12 +1,15 @@
 Metadata-Version: 2.4
 Name: SQLPyHelper
-Version: 0.1.1
+Version: 0.1.3
 Summary: A simple SQL database helper package for Python.
 Author: Adebayo Olaonipekun
 Author-email: pekunmi@live.com
 Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Database :: Database Engines/Servers
 Classifier: Operating System :: OS Independent
+Classifier: License :: OSI Approved :: MIT License
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
@@ -15,19 +18,29 @@ Requires-Dist: mysql-connector-python
 Requires-Dist: pyodbc
 Requires-Dist: cx_Oracle
 Requires-Dist: python-dotenv
+Provides-Extra: mysql
+Requires-Dist: mysql-connector-python; extra == "mysql"
+Provides-Extra: postgres
+Requires-Dist: psycopg2; extra == "postgres"
+Provides-Extra: oracle
+Requires-Dist: cx_Oracle; extra == "oracle"
+Provides-Extra: sqlserver
+Requires-Dist: pyodbc; extra == "sqlserver"
+Provides-Extra: sqlite
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: license-file
+Dynamic: provides-extra
 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)
@@ -40,24 +53,30 @@ 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
+#### Install via PyPI:
 ```sh
 pip install sqlpyhelper
 ```
-Or, if working from source:
+📌 Package on PyPI: [SQLPyHelper on PyPI](https://pypi.org/project/SQLPyHelper/)
+
+For local development:
 ```sh
 git clone https://github.com/adebayopeter/sqlpyhelper.git
 cd sqlpyhelper
@@ -75,11 +94,10 @@ DB_TYPE=postgres
 DB_HOST=localhost
 DB_USER=your_user
 DB_PASSWORD=your_secure_password
-DB_NAME=test_db
-DB_PORT=5432
+DB_NAME=database_name
 DB_DRIVER={ODBC Driver 17 for SQL Server}
 ORACLE_SID=XE
-ORACLE_PORT=1521
+ORACLE_DB_PORT=1521
 ```
 ### Loading `.env` in Code
 ```pycon
@@ -95,52 +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())
+```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
@@ -157,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.3/SQLPyHelper.egg-info/requires.txt

@@ -0,0 +1,19 @@
+psycopg2
+mysql-connector-python
+pyodbc
+cx_Oracle
+python-dotenv
+
+[mysql]
+mysql-connector-python
+
+[oracle]
+cx_Oracle
+
+[postgres]
+psycopg2
+
+[sqlite]
+
+[sqlserver]
+pyodbc

{sqlpyhelper-0.1.1 → 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.1',
+    version='0.1.3',
     description='A simple SQL database helper package for Python.',
     long_description=long_description,
     long_description_content_type="text/markdown",
@@ -19,10 +19,20 @@ setup(
         'cx_Oracle',
         'python-dotenv'
     ],
+    extras_require={
+        "mysql": ["mysql-connector-python"],
+        "postgres": ["psycopg2"],
+        "oracle": ["cx_Oracle"],
+        "sqlserver": ["pyodbc"],
+        "sqlite": []
+    },
     python_requires=">=3.8",
     classifiers=[
         "Programming Language :: Python :: 3",
-        "License :: OSI Approved :: MIT License",
-        "Operating System :: OS Independent"
+        "Development Status :: 5 - Production/Stable",
+        "Intended Audience :: Developers",
+        "Topic :: Database :: Database Engines/Servers",
+        "Operating System :: OS Independent",
+        "License :: OSI Approved :: MIT License"
     ],
 )

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

@@ -1,2 +1,2 @@
 # Match the version in setup.py
-__version__ = "0.1.1"
+__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.1/README.md

@@ -1,159 +0,0 @@
-# 📌 SQLPyHelper
-
-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.
-
-## 📖 Table of Contents
-- [🚀 Features](#-features)
-- [📦 Installation](#-installation)
-- [⚙️ Setup Using `.env`](#️-setup-using-env)
-- [🛠 Usage Examples](#-usage-examples)
-  - [SQLite Example](#sqlite-example)
-  - [PostgreSQL Example](#postgresql-example)
-  - [MySQL Example](#mysql-example)
-  - [SQL Server Example](#sql-server-example)
-  - [Oracle Example](#oracle-example)
-- [📂 Project Structure](#-project-structure)
-- [🌍 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**  
-
----
-## 📦 Installation
-```sh
-pip install sqlpyhelper
-```
-Or, if working from source:
-```sh
-git clone https://github.com/adebayopeter/sqlpyhelper.git
-cd sqlpyhelper
-pip install -r requirements.txt
-```
-
----
-
-## ⚙️ Setup Using `.env`
-Create a `.env` file in your project root to manage database configurations securely by renaming `.env_example`.
-
-```sh
-# .env_example (Rename to .env)
-DB_TYPE=postgres
-DB_HOST=localhost
-DB_USER=your_user
-DB_PASSWORD=your_secure_password
-DB_NAME=test_db
-DB_PORT=5432
-DB_DRIVER={ODBC Driver 17 for SQL Server}
-ORACLE_SID=XE
-ORACLE_PORT=1521
-```
-### Loading `.env` in Code
-```pycon
-from dotenv import load_dotenv
-import os
-
-load_dotenv()
-db_type = os.getenv("DB_TYPE")
-host = os.getenv("DB_HOST")
-user = os.getenv("DB_USER")
-password = os.getenv("DB_PASSWORD")
-database = os.getenv("DB_NAME")
-```
----
-## 🛠 Usage Examples
-### SQLite Example
-```pycon
-from sqlpyhelper.db_helper import SQLPyHelper
-
-db = SQLPyHelper()
-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())
-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()
-```
-### 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()
-```
-### 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()
-```
-### 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()
-```
-
-## 📂 Project Structure
-```
-📦 SQLPyHelper/
-├─ sqlpyhelper/
-│  ├─ __init__.py
-│  └─ db_helper.py
-├─ tests/
-│  └─ test_sqlpyhelper.py
-├─ .env_example
-├─ .gitignore
-├─ setup.py
-├─ README.md
-└─ requirements.txt
-```
-
----
-## 🌍 Contributing
-We welcome contributions from the **open-source community**! Follow these steps to contribute:
-
-1. Fork the repo: [SQLPyHelper GitHub Repository](https://github.com/adebayopeter/sqlpyhelper)
-2. Clone your fork:
-   ```sh
-   git clone https://github.com/adebayopeter/sqlpyhelper.git
-   ```
-3. Create a new branch:
-   ```sh
-   git checkout -b feature-new-functionality
-   ```
-4. Make changes, commit, and push:
-   ```sh
-   git commit -m "Added new feature"
-   git push origin feature-new-functionality
-   ```
-5. Submit a Pull Request!
-
----
-## ☕ Support the Project
-
-If you find SQLPyHelper useful, consider buying me a coffee to support continued development! 
-Donate Here: [PayPal](https://paypal.me/adebayopeter?country.x=GB&locale.x=en_GB)
----

sqlpyhelper-0.1.1/SQLPyHelper.egg-info/requires.txt

@@ -1,5 +0,0 @@
-psycopg2
-mysql-connector-python
-pyodbc
-cx_Oracle
-python-dotenv

sqlpyhelper-0.1.1/sqlpyhelper/db_helper.py

@@ -1,128 +0,0 @@
-import sqlite3
-import psycopg2
-import mysql.connector
-import pyodbc
-import cx_Oracle
-import csv
-from psycopg2 import pool
-from dotenv import load_dotenv
-import os
-
-load_dotenv()  # Load environment variables from .env file
-
-
-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")
-
-        if self.db_type == "sqlite":
-            self.connection = sqlite3.connect(self.database)
-        elif self.db_type == "postgres":
-            self.connection = psycopg2.connect(host=self.host, user=self.user,
-                                               password=self.password, dbname=self.database)
-        elif self.db_type == "mysql":
-            self.connection = mysql.connector.connect(host=self.host, user=self.user,
-                                                      password=self.password, database=self.database)
-        elif self.db_type == "sqlserver":
-            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":
-            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_all(self):
-        """Fetches all rows from the last executed query"""
-        return self.cursor.fetchall()
-
-    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 log_query(self, query):
-        """Logs queries for debugging purposes."""
-        with open("query_log.txt", "a") as f:
-            f.write(query + "\n")
-
-    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)
-        """
-        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.1/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()