SQLPyHelper 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

sqlpyhelper/__init__.py

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

sqlpyhelper/db_helper.py

@@ -1,16 +1,16 @@
-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
 
 
+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()
@@ -20,19 +20,25 @@ class SQLPyHelper:
         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)
@@ -50,16 +56,46 @@ class SQLPyHelper:
                 self.cursor.execute(query)
             self.connection.commit()
         except Exception as e:
-            print(f"Error executing query: {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"""
-        return self.cursor.fetchall()
+        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"""
-        self.cursor.close()
-        self.connection.close()
+        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):
         """
@@ -67,9 +103,13 @@ class SQLPyHelper:
         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)
+        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):
         """
@@ -77,17 +117,17 @@ class SQLPyHelper:
         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")
+        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):
         """
@@ -95,34 +135,75 @@ class SQLPyHelper:
         Example:
         backup_table('users', 'users_backup.csv')
         """
-        query = f"SELECT * FROM {table_name}"
-        self.execute_query(query)
-        rows = self.fetch_all()
+        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
 
-        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_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)
 
-    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)
+            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.getconn()
+        return self.pool.get_connection()
 
-    def return_connection_to_pool(self, conn):
+    def return_connection_to_pool(self):
         """Returns a connection back to the pool."""
-        self.pool.putconn(conn)
+        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.1.dist-info → sqlpyhelper-0.1.3.dist-info}/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,7 @@
+sqlpyhelper/__init__.py,sha256=v4m1w8m6t3Ypvteu4Ukto47uZG_pAHHkBFcKjWrk__Q,54
+sqlpyhelper/db_helper.py,sha256=hRgwzPM5Ze_xKwgphQLJovQmkVpVhKffmAa1C7Lje9g,8447
+sqlpyhelper-0.1.3.dist-info/licenses/LICENSE,sha256=9XzXxZ_8mWFM9-2TlqyE3L69zvRf4VPY_xIzSj5iU-g,1076
+sqlpyhelper-0.1.3.dist-info/METADATA,sha256=zYkK-eNm3BBm4T0bStWMSWdIR44pyWQgJOjUHh6lnQ8,7253
+sqlpyhelper-0.1.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sqlpyhelper-0.1.3.dist-info/top_level.txt,sha256=FrLqTmqTGDa8jHnnf2ZVkYO-gFvLXX9QonpUCE6wKGs,12
+sqlpyhelper-0.1.3.dist-info/RECORD,,

sqlpyhelper-0.1.1.dist-info/RECORD

@@ -1,7 +0,0 @@
-sqlpyhelper/__init__.py,sha256=QB8qTXgxfZC3LzFVHrC0Ou__78Z80itF8ifXmsTG-7Y,54
-sqlpyhelper/db_helper.py,sha256=9z2WjA7tQaNZ1fd1TYZZAooJS2N8szescOtTMNDTCgE,4896
-sqlpyhelper-0.1.1.dist-info/licenses/LICENSE,sha256=9XzXxZ_8mWFM9-2TlqyE3L69zvRf4VPY_xIzSj5iU-g,1076
-sqlpyhelper-0.1.1.dist-info/METADATA,sha256=BjUg9nZ5PW-TjpA46g8DV8H9Q3NMWgKSqdWD5VK0_V0,5211
-sqlpyhelper-0.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sqlpyhelper-0.1.1.dist-info/top_level.txt,sha256=FrLqTmqTGDa8jHnnf2ZVkYO-gFvLXX9QonpUCE6wKGs,12
-sqlpyhelper-0.1.1.dist-info/RECORD,,