json2sql-sql 0.1.2__py3-none-any.whl

json2sql-sql/__init__.py

@@ -0,0 +1,3 @@
+from .converter import Converter
+
+__all__ = ["Converter"]

json2sql-sql/converter.py

@@ -0,0 +1,80 @@
+from typing import Any, Dict, List, Optional
+
+from .loader import load_json, normalize_json_data
+from .flattener import flatten_json
+from .schema import detect_schema
+from .generator import generate_create_table_query, generate_insert_queries
+from .exporter import export_sql
+
+
+class Converter:
+    """
+    Main class for converting JSON data into SQL queries.
+    """
+
+    def __init__(self, source: Any, flatten: bool = True, separator: str = "_") -> None:
+        """
+        source can be:
+        - file path to JSON
+        - dict
+        - list of dicts
+        """
+        self.source = source
+        self.flatten = flatten
+        self.separator = separator
+
+        self.records: List[Dict[str, Any]] = []
+        self.schema: Dict[str, str] = {}
+        self.table_name: Optional[str] = None
+        self.create_query: Optional[str] = None
+        self.insert_queries: List[str] = []
+
+        self._load_and_prepare()
+
+    def _load_and_prepare(self) -> None:
+        if isinstance(self.source, str):
+            raw_records = load_json(self.source)
+        else:
+            raw_records = normalize_json_data(self.source)
+
+        if self.flatten:
+            self.records = [flatten_json(record, sep=self.separator) for record in raw_records]
+        else:
+            self.records = raw_records
+
+        self.schema = detect_schema(self.records)
+
+    def create_table(self, table_name: str) -> str:
+        self.table_name = table_name
+        self.create_query = generate_create_table_query(table_name, self.schema)
+        return self.create_query
+
+    def insert_data(self, table_name: Optional[str] = None) -> List[str]:
+        if table_name:
+            self.table_name = table_name
+
+        if not self.table_name:
+            raise ValueError("Table name is not set. Call create_table(table_name) first.")
+
+        self.insert_queries = generate_insert_queries(self.table_name, self.records, self.schema)
+        return self.insert_queries
+
+    def convert(self, table_name: str) -> str:
+        """
+        Generate full SQL as a single string.
+        """
+        create_query = self.create_table(table_name)
+        insert_queries = self.insert_data()
+
+        sql_parts = [create_query, ""]
+        sql_parts.extend(insert_queries)
+        return "\n".join(sql_parts)
+
+    def export(self, output_path: str) -> None:
+        if not self.create_query:
+            raise ValueError("Create query not generated. Call create_table(table_name) first.")
+
+        if not self.insert_queries:
+            raise ValueError("Insert queries not generated. Call insert_data() first.")
+
+        export_sql(output_path, self.create_query, self.insert_queries)

json2sql-sql/exceptions.py

@@ -0,0 +1,10 @@
+class Json2SqlError(Exception):
+    """Base exception for json2sql library."""
+
+
+class InvalidJsonError(Json2SqlError):
+    """Raised when JSON input is invalid."""
+
+
+class SchemaDetectionError(Json2SqlError):
+    """Raised when schema detection fails."""

json2sql-sql/exporter.py

@@ -0,0 +1,11 @@
+from typing import List
+
+
+def export_sql(output_path: str, create_query: str, insert_queries: List[str]) -> None:
+    """
+    Export SQL queries to a .sql file.
+    """
+    with open(output_path, "w", encoding="utf-8") as file:
+        file.write(create_query + "\n\n")
+        for query in insert_queries:
+            file.write(query + "\n")

json2sql-sql/flattener.py

@@ -0,0 +1,31 @@
+from typing import Any, Dict
+
+
+def flatten_json(data: Dict[str, Any], parent_key: str = "", sep: str = "_") -> Dict[str, Any]:
+    """
+    Flatten nested JSON.
+    Example:
+    {
+        "id": 1,
+        "address": {"city": "Chennai"}
+    }
+    becomes:
+    {
+        "id": 1,
+        "address_city": "Chennai"
+    }
+    """
+    items: Dict[str, Any] = {}
+
+    for key, value in data.items():
+        new_key = f"{parent_key}{sep}{key}" if parent_key else key
+
+        if isinstance(value, dict):
+            items.update(flatten_json(value, new_key, sep))
+        elif isinstance(value, list):
+            # Store lists as JSON-like strings in first version
+            items[new_key] = str(value)
+        else:
+            items[new_key] = value
+
+    return items

json2sql-sql/generator.py

@@ -0,0 +1,48 @@
+from typing import Any, Dict, List
+
+from .utils import sanitize_identifier, sql_escape
+
+
+def generate_create_table_query(table_name: str, schema: Dict[str, str]) -> str:
+    """
+    Generate CREATE TABLE query.
+    """
+    safe_table = sanitize_identifier(table_name)
+
+    columns = []
+    for column_name, sql_type in schema.items():
+        safe_column = sanitize_identifier(column_name)
+        columns.append(f"    {safe_column} {sql_type}")
+
+    columns_sql = ",\n".join(columns)
+
+    return f"CREATE TABLE {safe_table} (\n{columns_sql}\n);"
+
+
+def generate_insert_queries(table_name: str, records: List[Dict[str, Any]], schema: Dict[str, str]) -> List[str]:
+    """
+    Generate INSERT INTO queries.
+    """
+    safe_table = sanitize_identifier(table_name)
+    ordered_columns = list(schema.keys())
+    queries: List[str] = []
+
+    for record in records:
+        values = []
+        for column in ordered_columns:
+            original_value = None
+
+            for key, value in record.items():
+                if sanitize_identifier(key) == column:
+                    original_value = value
+                    break
+
+            values.append(sql_escape(original_value))
+
+        columns_sql = ", ".join(ordered_columns)
+        values_sql = ", ".join(values)
+
+        query = f"INSERT INTO {safe_table} ({columns_sql}) VALUES ({values_sql});"
+        queries.append(query)
+
+    return queries

json2sql-sql/loader.py

@@ -0,0 +1,38 @@
+import json
+from typing import Any, List, Dict
+
+from .exceptions import InvalidJsonError
+
+
+def load_json(source: str) -> List[Dict[str, Any]]:
+    """
+    Load JSON data from a file path.
+
+    Supported input:
+    - list of dictionaries
+    - single dictionary (converted to list with one item)
+    """
+    try:
+        with open(source, "r", encoding="utf-8") as file:
+            data = json.load(file)
+    except FileNotFoundError as exc:
+        raise InvalidJsonError(f"JSON file not found: {source}") from exc
+    except json.JSONDecodeError as exc:
+        raise InvalidJsonError(f"Invalid JSON format in file: {source}") from exc
+
+    return normalize_json_data(data)
+
+
+def normalize_json_data(data: Any) -> List[Dict[str, Any]]:
+    """
+    Normalize JSON input into a list of dictionaries.
+    """
+    if isinstance(data, dict):
+        return [data]
+
+    if isinstance(data, list):
+        if all(isinstance(item, dict) for item in data):
+            return data
+        raise InvalidJsonError("JSON list must contain only objects/dictionaries.")
+
+    raise InvalidJsonError("JSON must be a dictionary or a list of dictionaries.")

json2sql-sql/schema.py

@@ -0,0 +1,74 @@
+from typing import Any, Dict, List
+
+from .exceptions import SchemaDetectionError
+from .utils import sanitize_identifier
+
+
+def detect_sql_type(value: Any) -> str:
+    """
+    Detect SQL type from Python value.
+    """
+    if value is None:
+        return "TEXT"
+
+    if isinstance(value, bool):
+        return "BOOLEAN"
+
+    if isinstance(value, int) and not isinstance(value, bool):
+        return "INTEGER"
+
+    if isinstance(value, float):
+        return "REAL"
+
+    return "TEXT"
+
+
+def merge_sql_types(type1: str, type2: str) -> str:
+    """
+    Merge conflicting SQL types into a safer common type.
+    """
+    priority = ["BOOLEAN", "INTEGER", "REAL", "TEXT"]
+
+    if type1 == type2:
+        return type1
+
+    # If either is TEXT, safest is TEXT
+    if "TEXT" in (type1, type2):
+        return "TEXT"
+
+    # INTEGER + REAL => REAL
+    if {"INTEGER", "REAL"} == {type1, type2}:
+        return "REAL"
+
+    # BOOLEAN mixed with anything else => TEXT
+    if "BOOLEAN" in (type1, type2):
+        return "TEXT"
+
+    return priority[max(priority.index(type1), priority.index(type2))]
+
+
+def detect_schema(records: List[Dict[str, Any]]) -> Dict[str, str]:
+    """
+    Detect schema from list of flattened records.
+    Returns dict like:
+    {
+        "id": "INTEGER",
+        "name": "TEXT"
+    }
+    """
+    if not records:
+        raise SchemaDetectionError("No records found for schema detection.")
+
+    schema: Dict[str, str] = {}
+
+    for record in records:
+        for key, value in record.items():
+            safe_key = sanitize_identifier(key)
+            current_type = detect_sql_type(value)
+
+            if safe_key in schema:
+                schema[safe_key] = merge_sql_types(schema[safe_key], current_type)
+            else:
+                schema[safe_key] = current_type
+
+    return schema

json2sql-sql/utils.py

@@ -0,0 +1,40 @@
+import re
+from typing import Any
+
+
+def sanitize_identifier(name: str) -> str:
+    """
+    Convert any string into a safe SQL identifier.
+    Example: 'user name' -> 'user_name'
+    """
+    if not isinstance(name, str):
+        name = str(name)
+
+    name = name.strip().lower()
+    name = re.sub(r"[^a-zA-Z0-9_]", "_", name)
+    name = re.sub(r"_+", "_", name)
+
+    if not name:
+        name = "column"
+
+    if name[0].isdigit():
+        name = f"col_{name}"
+
+    return name
+
+
+def sql_escape(value: Any) -> str:
+    """
+    Escape Python values for SQL INSERT statements.
+    """
+    if value is None:
+        return "NULL"
+
+    if isinstance(value, bool):
+        return "TRUE" if value else "FALSE"
+
+    if isinstance(value, (int, float)):
+        return str(value)
+
+    value = str(value).replace("'", "''")
+    return f"'{value}'"

json2sql_sql-0.1.2.dist-info/METADATA

@@ -0,0 +1,24 @@
+Metadata-Version: 2.4
+Name: json2sql-sql
+Version: 0.1.2
+Summary: Convert JSON data into SQL queries
+Author: NaveenKumar
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Dynamic: requires-python
+
+# json2sql
+
+A simple Python library to convert JSON data into SQL queries.
+
+## Features
+
+- Auto table creation
+- Insert query generation
+- Schema detection
+- Nested JSON flattening
+
+## Installation
+
+```bash
+pip install -r requirements.txt

json2sql_sql-0.1.2.dist-info/RECORD

@@ -0,0 +1,15 @@
+json2sql-sql/__init__.py,sha256=AhwSX-wiMz6_eRZw9fZWNdV0UxwpNWWTRqw5tQhL_Io,59
+json2sql-sql/converter.py,sha256=x4huzNq2bZBi5D_iRwo7Gg1Th17OTGCxze-tSpa33Yk,2751
+json2sql-sql/exceptions.py,sha256=ZaxZKe6Y5KxKM6efa_DWD1dKudcCanFnGpUMtItKkMY,264
+json2sql-sql/exporter.py,sha256=rDRSa3WgdSOpifqsb7U0MgCXcRMIOY0wKzS47ngI5rM,353
+json2sql-sql/flattener.py,sha256=nzZjovL0yFoqkyIhArGGxlGw-s-j1bxLa9NwgYwsKhM,795
+json2sql-sql/generator.py,sha256=Uiwi41Qw9TUaj5tsmKS7HnGGIuN1CUi5I3pWRlP0Zig,1448
+json2sql-sql/loader.py,sha256=ZX6C-_Dx-8iQGvm5IosAwE7CPt6-e6Bu_VEDRlmEoTs,1178
+json2sql-sql/schema.py,sha256=EaHFIEdDM_kR2H9DAnuNdAvl91jUXOYu_l552rOAQ40,1875
+json2sql-sql/utils.py,sha256=DyK4jmE_0c3xs_EmyJBbFTGVvg795J-NkePg6kQIAUQ,873
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/test_basic.py,sha256=PqTYfTs61aXeA8wOjKNsPdvOehqv6fWjVbQnzGNlH6U,479
+json2sql_sql-0.1.2.dist-info/METADATA,sha256=wF_yLn7OwG6UzxEoaKRZx6Tguulht5d95fhxtM1lqYs,472
+json2sql_sql-0.1.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+json2sql_sql-0.1.2.dist-info/top_level.txt,sha256=3VbAySvqtpdFa4jPTdJ-qPiRurynhaGylH-H654GulY,19
+json2sql_sql-0.1.2.dist-info/RECORD,,

json2sql_sql-0.1.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

json2sql_sql-0.1.2.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+json2sql-sql
+tests

tests/test_basic.py

@@ -0,0 +1,17 @@
+from json2sql import Converter
+
+
+def test_basic_conversion():
+    data = [
+        {"id": 1, "name": "Naveen", "address": {"city": "Chennai"}},
+        {"id": 2, "name": "Kumar", "address": {"city": "Madurai"}}
+    ]
+
+    converter = Converter(data)
+    sql = converter.convert("users")
+
+    assert "CREATE TABLE users" in sql
+    assert "id INTEGER" in sql
+    assert "name TEXT" in sql
+    assert "address_city TEXT" in sql
+    assert "INSERT INTO users" in sql