SQLPyHelper 0.1.0__tar.gz

sqlpyhelper-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Adebayo Olaonipekun
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

sqlpyhelper-0.1.0/PKG-INFO

@@ -0,0 +1,186 @@
+Metadata-Version: 2.4
+Name: SQLPyHelper
+Version: 0.1.0
+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: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: psycopg2
+Requires-Dist: mysql-connector-python
+Requires-Dist: pyodbc
+Requires-Dist: cx_Oracle
+Requires-Dist: python-dotenv
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# 📌 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.0/README.md

@@ -0,0 +1,159 @@
+# 📌 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.0/SQLPyHelper.egg-info/PKG-INFO

@@ -0,0 +1,186 @@
+Metadata-Version: 2.4
+Name: SQLPyHelper
+Version: 0.1.0
+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: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: psycopg2
+Requires-Dist: mysql-connector-python
+Requires-Dist: pyodbc
+Requires-Dist: cx_Oracle
+Requires-Dist: python-dotenv
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# 📌 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.0/SQLPyHelper.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+setup.py
+SQLPyHelper.egg-info/PKG-INFO
+SQLPyHelper.egg-info/SOURCES.txt
+SQLPyHelper.egg-info/dependency_links.txt
+SQLPyHelper.egg-info/requires.txt
+SQLPyHelper.egg-info/top_level.txt
+sqlpyhelper/__init__.py
+sqlpyhelper/db_helper.py
+test/test_sqlpyhelper.py

sqlpyhelper-0.1.0/SQLPyHelper.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

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

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

sqlpyhelper-0.1.0/SQLPyHelper.egg-info/top_level.txt

@@ -0,0 +1 @@
+sqlpyhelper

sqlpyhelper-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

sqlpyhelper-0.1.0/setup.py

@@ -0,0 +1,28 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as f:
+    long_description = f.read()
+
+setup(
+    name='SQLPyHelper',
+    version='0.1.0',
+    description='A simple SQL database helper package for Python.',
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    author='Adebayo Olaonipekun',
+    author_email='pekunmi@live.com',
+    packages=find_packages(),
+    install_requires=[
+        'psycopg2',
+        'mysql-connector-python',
+        'pyodbc',
+        'cx_Oracle',
+        'python-dotenv'
+    ],
+    python_requires=">=3.8",
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent"
+    ],
+)

sqlpyhelper-0.1.0/sqlpyhelper/db_helper.py

@@ -0,0 +1,128 @@
+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.0/test/test_sqlpyhelper.py

@@ -0,0 +1,71 @@
+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()