Add initial project structure and implementation for json2sqlite tool

Author: stefanopaolonii

README.md

@@ -1 +1,53 @@
-# json2sqlite
+# json2sqlite 🚀
+
+## Description 📄
+`json2sqlite` is a tool that allows importing data from a JSON file into an SQLite database. This project is useful for anyone who wants to transfer structured data from a JSON format to a relational database quickly and easily.
+
+## Project Structure 📁
+The project structure is as follows:
+```
+json2sqlite/
+│-- data/
+│   ├── data.json  # JSON file to be imported (to be placed manually in this directory)
+│-- src/
+│   ├── __init__.py         # Module initialization file
+│   ├── config.py           # Database and JSON file configuration
+│   ├── json_reader.py      # Module for reading the JSON file
+│   ├── logger.py           # Module for log management
+│   ├── main.py             # Main script for data import
+│   ├── sqlite_handler.py   # Module for SQLite database management
+│-- README.md               # Project documentation
+```
+
+## Requirements 📋
+- Python 3.x
+- Python modules: `sqlite3`, `json`, `logging`
+
+## Installation 💻
+1. Clone the repository:
+    ```sh
+    git clone https://github.com/stefanopaolonii/json2sqlite.git
+    cd json2sqlite
+    ```
+
+## Configuration ⚙️
+Edit the `config.py` file to specify:
+- The path to the JSON file (which must be placed in the `data/` directory)
+- The name of the SQLite database
+- The name of the table
+
+Example configuration:
+```python
+DB_FILE = 'database.sqlite'
+TABLE_NAME = 'my_table'
+JSON_FILE = 'data/data.json'
+```
+
+## Usage ▶️
+To run the script and import the JSON data into the SQLite database, execute the following command:
+```sh
+python -m src.main
+```
+
+## License 📜
+This project is distributed under the MIT license. See the `LICENSE` file for more details.

src/__init__.py

@@ -0,0 +1,3 @@
+DB_FILE= 'database.sqlite'
+TABLE_NAME='my_table'
+JSON_FILE='data/data.json'

src/config.py

@@ -0,0 +1,16 @@
+import json
+from src.logger import logger
+
+def load_json(file_path):
+    try:
+        with open(file_path, 'r') as file:
+            data = json.load(file)
+        logger.info(f'Loaded JSON file from {file_path}')
+        return data
+    except FileNotFoundError:
+        logger.error(f'File not found: {file_path}')
+    except json.JSONDecodeError:
+        logger.error(f'Invalid JSON file: {file_path}')
+    except Exception as e:
+        logger.error(f'Error loading JSON file: {file_path}')
+        raise

src/json_reader.py

@@ -0,0 +1,17 @@
+import logging
+
+def setup_logger():
+    logger = logging.getLogger('json_to_sqlite')
+    logger.setLevel(logging.DEBUG)
+
+    console_handler = logging.StreamHandler()
+    console_handler.setLevel(logging.INFO)
+
+    formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
+    console_handler.setFormatter(formatter)
+
+    logger.addHandler(console_handler)
+
+    return logger
+
+logger = setup_logger()

src/logger.py

@@ -0,0 +1,26 @@
+from src.config import DB_FILE, JSON_FILE, TABLE_NAME
+from src.json_reader import load_json
+from src.sqlite_handler import create_table, insert_data, connect_db
+from src.logger import logger
+
+def json_to_sqlite():
+    try:
+        data = load_json(JSON_FILE)
+        
+        if not data:
+            logger.warning("The JSON file is empty!")
+            return
+        
+        with connect_db(DB_FILE) as conn:
+            columns = data[0].keys()  
+            create_table(conn, TABLE_NAME, columns)
+            
+            insert_data(conn, TABLE_NAME, data)
+        
+        logger.info(f"Data from the JSON file has been inserted into the database {DB_FILE}")
+    
+    except Exception as e:
+        logger.error(f"An error occurred: {e}")
+
+if __name__ == "__main__":
+    json_to_sqlite()

src/main.py

@@ -0,0 +1,63 @@
+import sqlite3
+import json
+from typing import Any, Dict, List, Optional
+from src.logger import logger
+
+def infer_column_type(value: Any) -> str:
+    type_mapping = {
+        type(None): "NULL",
+        int: "INTEGER",
+        float: "REAL",
+        bool: "INTEGER",
+        str: "TEXT",
+        list: "TEXT",
+        dict: "TEXT"
+    }
+    return type_mapping.get(type(value), "TEXT")
+
+def create_table(conn: sqlite3.Connection, table_name: str, columns: List[str]) -> None:
+    column_definitions = [
+        f"{col} {infer_column_type(None)}" for col in columns
+    ]
+    columns_str = ', '.join(column_definitions)
+    create_table_query = f"CREATE TABLE IF NOT EXISTS {table_name} ({columns_str});"
+
+    try:
+        with conn:
+            conn.execute(create_table_query)
+        logger.info(f"Table '{table_name}' created successfully with correct data types.")
+    except sqlite3.DatabaseError as e:
+        logger.error(f"Error creating table '{table_name}': {e}")
+
+def insert_data(conn: sqlite3.Connection, table_name: str, data: List[Dict[str, Any]]) -> None:
+    if not data:
+        logger.warning("No data provided for insertion.")
+        return
+
+    columns = data[0].keys()
+    columns_str = ', '.join(columns)
+    placeholders = ', '.join(['?'] * len(columns))
+    insert_query = f"INSERT INTO {table_name} ({columns_str}) VALUES ({placeholders})"
+
+    try:
+        with conn:
+            for row in data:
+                row_values = [
+                    json.dumps(value) if isinstance(value, (dict, list)) else value
+                    for value in row.values()
+                ]
+                conn.execute(insert_query, tuple(row_values))
+        logger.info(f"{len(data)} records successfully inserted into table '{table_name}'.")
+    except sqlite3.IntegrityError as e:
+        logger.error(f"Integrity error inserting into table '{table_name}': {e}")
+    except sqlite3.DatabaseError as e:
+        logger.error(f"Database error inserting data into table '{table_name}': {e}")
+
+def connect_db(db_file: str) -> Optional[sqlite3.Connection]:
+    try:
+        conn = sqlite3.connect(db_file)
+        logger.info(f"Connected to database '{db_file}' successfully.")
+        return conn
+    except sqlite3.Error as e:
+        logger.error(f"Error connecting to database '{db_file}': {e}")
+        return None