sqloader 0.1.0__tar.gz

sqloader-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 horrible-gh
+
+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.

sqloader-0.1.0/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: sqloader
+Version: 0.1.0
+Summary: A simple and extensible SQL migration and loader utility for Python.
+Home-page: https://github.com/horrible-gh/LogAssist.git
+Author: horrible-gh
+Author-email: horrible <shinjpn1@gmail.com>
+Project-URL: Homepage, https://github.com/horrible-gh/sqloader
+Project-URL: Bug Tracker, https://github.com/horrible-gh/sqloader/issues
+Keywords: sqloader,sql loader,migration,database migration,MySQL,SQLite,SQL migration,schema management,json sql loader
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: LogAssist
+Requires-Dist: pymysql
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# sqloader
+
+A lightweight Python utility for managing SQL migrations and loading SQL from JSON or .sql files.
+Supports common relational databases and is designed for simple, clean integration with any Python backend (e.g., FastAPI).
+
+---
+
+## Installation
+
+```powershell
+pip install sqloader
+```
+
+## Features
+
+- ✅ Easy database migration management
+- ✅ Load SQL queries from `.json` or `.sql` files
+- ✅ Supports MySQL and SQLite
+- ✅ Clean API for integration
+- ✅ Lightweight and dependency-minimized
+
+## Quickstart
+
+```python
+from sqloader.init import database_init
+
+config = {
+    "type": "mysql",
+    "mysql": {
+        "host": "localhost",
+        "port": 3306,
+        "user": "root",
+        "password": "pass",
+        "database": "mydb"
+    },
+    "service": {
+        "sqloder": "res/sql/sqloader/mysql"
+    },
+    "migration": {
+        "auto_migration": True,
+        "migration_path": "res/sql/migration/mysql"
+    },
+}
+
+db, sqloader, migrator = database_init(config)
+
+# Example usage
+query = sqloader.load_sql("user_info", "user.get_user_by_id")
+result = db.select_one(query, (123,))
+
+```
+
+## SQL Loading Behavior
+
+- If the value in the .json file ends with .sql, the referenced file will be loaded from the same directory.
+- Otherwise, the value is treated as a raw SQL string.
+
+Example JSON file user.json:
+
+
+```json
+{
+  "user": {
+    "get_user_by_id": "SELECT * FROM users WHERE id = %s",
+    "get_all_users": "user_all.sql"
+  },
+  "get_etc": "SELECT * FROM etc"
+}
+```

sqloader-0.1.0/README.md

@@ -0,0 +1,69 @@
+# sqloader
+
+A lightweight Python utility for managing SQL migrations and loading SQL from JSON or .sql files.
+Supports common relational databases and is designed for simple, clean integration with any Python backend (e.g., FastAPI).
+
+---
+
+## Installation
+
+```powershell
+pip install sqloader
+```
+
+## Features
+
+- ✅ Easy database migration management
+- ✅ Load SQL queries from `.json` or `.sql` files
+- ✅ Supports MySQL and SQLite
+- ✅ Clean API for integration
+- ✅ Lightweight and dependency-minimized
+
+## Quickstart
+
+```python
+from sqloader.init import database_init
+
+config = {
+    "type": "mysql",
+    "mysql": {
+        "host": "localhost",
+        "port": 3306,
+        "user": "root",
+        "password": "pass",
+        "database": "mydb"
+    },
+    "service": {
+        "sqloder": "res/sql/sqloader/mysql"
+    },
+    "migration": {
+        "auto_migration": True,
+        "migration_path": "res/sql/migration/mysql"
+    },
+}
+
+db, sqloader, migrator = database_init(config)
+
+# Example usage
+query = sqloader.load_sql("user_info", "user.get_user_by_id")
+result = db.select_one(query, (123,))
+
+```
+
+## SQL Loading Behavior
+
+- If the value in the .json file ends with .sql, the referenced file will be loaded from the same directory.
+- Otherwise, the value is treated as a raw SQL string.
+
+Example JSON file user.json:
+
+
+```json
+{
+  "user": {
+    "get_user_by_id": "SELECT * FROM users WHERE id = %s",
+    "get_all_users": "user_all.sql"
+  },
+  "get_etc": "SELECT * FROM etc"
+}
+```

sqloader-0.1.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sqloader"
+version = "0.1.0"
+authors = [
+  { name="horrible", email="shinjpn1@gmail.com" },
+]
+description = "A simple and extensible SQL migration and loader utility for Python."
+readme = "README.md"
+requires-python = ">=3.7"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+keywords = [
+    "sqloader", "sql loader", "migration", "database migration",
+    "MySQL", "SQLite", "SQL migration", "schema management",
+    "json sql loader"
+]
+dependencies=['LogAssist', 'pymysql']
+
+[project.urls]
+"Homepage" = "https://github.com/horrible-gh/sqloader"
+"Bug Tracker" = "https://github.com/horrible-gh/sqloader/issues"

sqloader-0.1.0/setup.cfg

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

sqloader-0.1.0/setup.py

@@ -0,0 +1,28 @@
+from setuptools import setup, find_packages
+
+setup(
+    name='sqloader',
+    version='0.1.0',
+    description='LogAssist package',
+    author='horrible-gh',
+    author_email='shinjpn1@gmail.com',
+    url='https://github.com/horrible-gh/LogAssist.git',
+    packages=find_packages(),
+    classifiers=[
+        'Development Status :: 3 - Alpha',
+        'Intended Audience :: Developers',
+        'License :: OSI Approved :: MIT License',
+        'Programming Language :: Python :: 3',
+        'Programming Language :: Python :: 3.6',
+        'Programming Language :: Python :: 3.7',
+        'Programming Language :: Python :: 3.8',
+        'Programming Language :: Python :: 3.9',
+        'Programming Language :: Python :: 3.10',
+        'Programming Language :: Python :: 3.11',
+    ],
+    python_requires='>=3.6',
+    install_requires=[
+        "LogAssist==1.1.1",
+        "pymysql==1.1.1"
+    ],
+)

sqloader-0.1.0/sqloader/__init__.py

@@ -0,0 +1,6 @@
+
+from ._prototype import DatabasePrototype
+from .sqlite3 import SQLiteWrapper
+from .mysql import MySqlWrapper
+from .sqloader import SQLoader
+from .migrator import DatabaseMigrator

sqloader-0.1.0/sqloader/_prototype.py

@@ -0,0 +1,101 @@
+import os
+
+SQLITE = 1
+MYSQL = 2
+
+
+class DatabasePrototype:
+    db_type = ""
+
+    def connect(self):
+        pass
+
+    def reconnect(self):
+        pass
+
+    def execute(self, query, params=None, commit=True):
+        pass
+
+    def execute_query(self, query, params=None, commit=True):
+        pass
+
+    def commit(self):
+        pass
+
+    def fetch_one(self, query, params=None):
+        pass
+
+    def fetch_all(self, query, params=None):
+        pass
+
+    def close(self):
+        pass
+
+    def escape_string(value):
+        if isinstance(value, str):
+            replacements = {
+                "'": "''",
+                "--": "––",
+                ";": "；",
+                "\\": "\\\\",
+                "%": "\\%",
+                "_": "\\_"
+            }
+
+            for old, new in replacements.items():
+                value = value.replace(old, new)
+
+        return value
+
+    def keep_alive(self, interval=600):
+        pass
+
+    def rollback(self):
+        pass
+
+    def set_sql_path(self, sql_path):
+        self.external_sql_path = sql_path
+
+    def load_sql(self, sql_file, directory="."):
+        if self.external_sql_path:
+            sql_path = f"{self.external_sql_path}/{directory}/{sql_file}"
+            if os.path.exists(sql_path):
+                with open(sql_path, 'r') as file:
+                    return file.read()
+            else:
+                raise FileNotFoundError(f"File not found: {sql_path}")
+        else:
+            raise RuntimeError("External sql directory not initialized.")
+
+    def keep_alive(self):
+        pass
+
+    def begin_transaction(self):
+        pass
+class Transaction:
+    def __init__(self, wrapper):
+        pass
+
+    def execute(self, query, params=None):
+        pass
+
+    def fetchall(self):
+        pass
+
+    def fetchone(self):
+        pass
+
+    def commit(self):
+        pass
+
+    def rollback(self):
+        pass
+
+    def close(self):
+        pass
+
+    def __enter__(self):
+        pass
+
+    def __exit__(self, exc_type, exc_val, traceback):
+        pass

sqloader-0.1.0/sqloader/init.py

@@ -0,0 +1,69 @@
+import LogAssist.log as Logger
+from . import MySqlWrapper, SQLiteWrapper, DatabaseMigrator, SQLoader
+
+
+
+def check_and_get(config, target):
+    val = config.get(target, None)
+    if val != None:
+        return val
+    else:
+        raise Exception(f"Require value {target}")
+
+def database_init(db_config):
+    db_instance = None
+
+    db_type = check_and_get(db_config, "type")
+    dbconn_info = db_config[db_type]
+
+    if db_type == "mysql":
+        host = check_and_get(dbconn_info, "host")
+        user = check_and_get(dbconn_info, "user")
+        password = check_and_get(dbconn_info, "password")
+        database = check_and_get(dbconn_info, "database")
+        port = dbconn_info.get("port", None)
+        log = dbconn_info.get("log", False)
+
+        if port != None:
+            mysql = MySqlWrapper(host=host, user=user, password=password, db=database, port=port, log=log)
+        else :
+            mysql = MySqlWrapper(host=host, user=user, password=password, db=database, log=log)
+        db_instance = mysql
+        Logger.debug("MySQL initialized")
+    elif db_type == "sqlite3" or db_type == "sqlite" or db_type == "local":
+        db_name = check_and_get(dbconn_info, "db_name")
+        sqlite3 = SQLiteWrapper(db_name=db_name)
+        db_instance = sqlite3
+        Logger.debug("SQLite3 initialized")
+
+
+    db_service = db_config.get("service", None)
+    sqloader = None
+
+    if db_service != None:
+        sqloader_path = db_service.get('sqloder', None)
+        if sqloader_path != None:
+            sqloader = SQLoader(sqloader_path)
+    Logger.debug("SQLoader initialized")
+
+    migration_config = db_config.get('migration', None)
+    migrator = None
+    Logger.debug(migration_config)
+
+    if migration_config != None:
+        try:
+            migration_path = check_and_get(migration_config, 'migration_path')
+            auto_migration = migration_config.get("auto_migration", False)
+
+            Logger.debug("Starting Database Migrator")
+            migrator = DatabaseMigrator(
+                db_instance, migration_path, auto_migration)
+            Logger.debug("Database Migration Successfully")
+        except Exception as e:
+            Logger.error(f"Database Migration Failed.{e}")
+            exit(1)
+
+    return db_instance, sqloader, migrator
+
+
+

sqloader-0.1.0/sqloader/migrator.py

@@ -0,0 +1,95 @@
+import os
+import glob
+from ._prototype import DatabasePrototype, MYSQL, SQLITE
+
+class DatabaseMigrator:
+    def __init__(self, db: DatabasePrototype, migrations_path, auto_run=False):
+        """
+        :param db:       MySQL 또는 SQLite 래퍼 객체
+        :param migrations_path: .sql 파일들이 들어 있는 폴더 경로 (절대 또는 상대)
+        :param auto_run: True일 경우, 초기화 시점에 자동으로 마이그레이션 적용
+        """
+        self.db = db
+        # migrations_path를 절대 경로로 저장 (os.path.abspath 등)
+        self.migrations_path = os.path.abspath(migrations_path)
+        self.create_migrations_table()
+        if auto_run:
+            self.apply_migrations()
+
+    def create_migrations_table(self):
+        """마이그레이션 기록용 테이블 생성"""
+        if self.db.db_type == MYSQL:
+            self.db.execute("""
+                CREATE TABLE IF NOT EXISTS migrations (
+                    filename VARCHAR(255) PRIMARY KEY,
+                    applied_at DATETIME DEFAULT CURRENT_TIMESTAMP
+                );
+            """, None, commit=True)
+        elif self.db.db_type == SQLITE:
+            self.db.execute("""
+                CREATE TABLE IF NOT EXISTS migrations (
+                    filename TEXT PRIMARY KEY,
+                    applied_at DATETIME DEFAULT CURRENT_TIMESTAMP
+                );
+            """, None, commit=True)
+        self.db.commit()
+
+    def apply_migrations(self):
+        """아직 적용 안 된 마이그레이션 파일(.sql)들을 순서대로 실행"""
+        applied_migrations = self.get_applied_migrations()
+        for migration in self.get_migration_files():
+            # migration: "001_init.sql", "002_update.sql" 처럼 '상대 경로'만
+            if migration not in applied_migrations:
+                self.apply_migration(migration)
+
+    def apply_migration(self, migration):
+        full_path = os.path.join(self.migrations_path, migration)
+
+        with open(full_path, 'r', encoding='utf-8') as f:
+            sql_commands = f.read().split(';')
+
+        try:
+            # begin_transaction()을 통해 트랜잭션 컨텍스트 사용
+            with self.db.begin_transaction() as txn:
+                for command in sql_commands:
+                    command = command.strip()
+                    if command:
+                        txn.execute(command)
+                # 트랜잭션 블록이 종료되면서 commit (예외 발생 시 rollback)
+
+            if self.db.db_type == SQLITE:
+                placeholder = '?'
+            else:
+                placeholder = '%s'
+
+            self.db.execute(
+                f"INSERT INTO migrations (filename) VALUES ({placeholder})",
+                (migration,),
+                commit=True
+            )
+
+            print(f"Migration {migration} applied successfully.")
+        except Exception as e:
+            raise Exception(f"Failed to apply migration {migration}: {e}")
+
+    def get_migration_files(self):
+        """
+        마이그레이션 폴더 내 *.sql 파일을 찾아,
+        'migrations_path'로부터의 상대 경로 목록을 반환
+        """
+        # 예: ["C:/path/to/migrations/001_init.sql", ...]
+        all_files = sorted(glob.glob(os.path.join(self.migrations_path, "*.sql")))
+        # 상대 경로만 추출 => ["001_init.sql", ...]
+        migration_files = [
+            os.path.relpath(f, self.migrations_path)
+            for f in all_files
+        ]
+        return migration_files
+
+    def get_applied_migrations(self):
+        """
+        DB에 이미 적용된 마이그레이션의 filename 목록을 set으로 반환
+        여기서 'filename'은 위에서 INSERT한 것과 동일(상대 경로)
+        """
+        rows = self.db.fetch_all("SELECT filename FROM migrations")
+        return {row['filename'] for row in rows}

sqloader-0.1.0/sqloader/mysql.py

@@ -0,0 +1,288 @@
+import pymysql
+import os
+import threading
+from ._prototype import DatabasePrototype, Transaction, MYSQL
+from pymysql.cursors import DictCursor
+from time import sleep
+
+query_semaphore = None
+
+class MySqlWrapper(DatabasePrototype):
+    db_type = MYSQL
+    log_print = False
+    external_sql_path = None
+
+    def __init__(self, host, user, password, db, port=3306, log=False, keep_alive_interval=-1, sql_path=None, max_parallel_queries=5):
+        self.host = host
+        self.user = user
+        self.password = password
+        self.db = db
+        self.port = port
+        self.log_print = log
+        self.external_sql_path = sql_path
+
+        global query_semaphore
+        query_semaphore = threading.Semaphore(max_parallel_queries)
+
+        # 기존 self.conn, self.cursor를 제거하거나 사용 안 함
+        # connect()와 keep_alive()는 사실상 필요 없어질 수 있음
+        # 하지만 혹시 모를 호환을 위해 그대로 둠
+        self.connect()
+
+        if keep_alive_interval > 0:
+            self.keep_alive_interval = keep_alive_interval
+            self.keep_alive_thread = threading.Thread(target=self.keep_alive, daemon=True)
+            self.keep_alive_thread.start()
+
+    def connect(self):
+        """기존 코드 호환을 위해 남겨둠, 하지만 execute_query에는 사용하지 않음."""
+        self.conn = pymysql.connect(
+            host=self.host,
+            user=self.user,
+            password=self.password,
+            db=self.db,
+            port=self.port,
+            cursorclass=DictCursor
+        )
+        self.cursor = self.conn.cursor()
+
+    def reconnect(self):
+        """호환 유지. 다만 '매번 새 커넥션' 방식에서는 큰 의미가 없어집니다."""
+        try:
+            self.conn.ping(reconnect=True)
+        except:
+            self.connect()
+
+    def log(self, msg):
+        if self.log_print:
+            print(msg)
+
+    def normalize_params(self, params):
+        """ dict 형태의 params를 list로 변환하는 유틸리티 함수 """
+        if params is None:
+            return None
+        if isinstance(params, dict):
+            return list(params.values())  # ✅ dict -> list 변환
+        return params  # ✅ 이미 list라면 그대로 반환
+
+
+    def execute_query(self, query, params=None, commit=True, retry=1):
+        # 세마포어로 동시 실행 쿼리 수 제한
+        query_semaphore.acquire()
+        try:
+            conn = pymysql.connect(
+                host=self.host,
+                user=self.user,
+                password=self.password,
+                db=self.db,
+                port=self.port,
+                cursorclass=DictCursor
+            )
+            try:
+                with conn.cursor(DictCursor) as cursor:
+                    if params is None:
+                        self.log(query)
+                        result = cursor.execute(query)
+                    else:
+                        self.log(query)
+                        self.log(params)
+                        # 파라미터가 dict면 리스트로 변환하는 처리
+                        params = self.normalize_params(params)
+                        result = cursor.execute(query, params)
+
+                    if commit:
+                        conn.commit()
+                return result
+
+            except pymysql.MySQLError as e:
+                print(f"Error executing query: {e}")
+                print(f"Last query: {query}")
+                # rollback 시도
+                try:
+                    conn.rollback()
+                except Exception as ex:
+                    print(f"Rollback failed: {ex}")
+                # 세션 끊김(2006) 에러 발생 시 재시도
+                if e.args[0] == 2006 and retry > 0:
+                    print("MySQL server has gone away. Reconnecting and retrying query...")
+                    conn.close()
+                    return self.execute_query(query, params, commit, retry=retry-1)
+                else:
+                    raise e
+            finally:
+                try:
+                    conn.close()
+                except Exception as ex:
+                    print(f"Closing connection failed: {ex}")
+        finally:
+            query_semaphore.release()
+
+
+    # execute()도 동일하게 수정
+    def execute(self, query, params=None, commit=True):
+        return self.execute_query(query, params, commit)
+
+    # fetch_all, fetch_one도 동일한 패턴으로 새 커넥션 쓰도록
+    def fetch_all(self, query, params=None):
+        query_semaphore.acquire()
+        try:
+            conn = pymysql.connect(
+                host=self.host,
+                user=self.user,
+                password=self.password,
+                db=self.db,
+                port=self.port,
+                cursorclass=DictCursor
+            )
+            with conn.cursor(DictCursor) as cursor:
+                # 파라미터가 dict면 리스트로 변환하는 처리
+                params = self.normalize_params(params)
+                if params is None:
+                    self.log(query)
+                    cursor.execute(query)
+                else:
+                    self.log(query)
+                    self.log(params)
+                    cursor.execute(query, params)
+                return cursor.fetchall()
+        except pymysql.MySQLError as e:
+            print(f"Error fetching data: {e}")
+            print(f"Last query: {query}")
+            if e.args[0] == 2006:
+                pass  # 재시도 로직 가능
+            raise e
+        finally:
+            try:
+                conn.close()
+            except:
+                pass
+            query_semaphore.release()
+
+    def fetch_one(self, query, params=None):
+        query_semaphore.acquire()
+        try:
+            conn = pymysql.connect(
+                host=self.host,
+                user=self.user,
+                password=self.password,
+                db=self.db,
+                port=self.port,
+                cursorclass=DictCursor
+            )
+            with conn.cursor(DictCursor) as cursor:
+                # 파라미터가 dict면 리스트로 변환하는 처리
+                params = self.normalize_params(params)
+                if params is None:
+                    self.log(query)
+                    cursor.execute(query)
+                else:
+                    self.log(query)
+                    self.log(params)
+                    cursor.execute(query, params)
+                return cursor.fetchone()
+        except pymysql.MySQLError as e:
+            print(f"Error fetching data: {e}")
+            print(f"Last query: {query}")
+
+            if e.args[0] == 2006:
+                pass  # 재시도 로직 가능
+            raise e
+        finally:
+            try:
+                conn.close()
+            except:
+                pass
+            query_semaphore.release()
+
+    def commit(self):
+        # 더 이상 self.conn을 쓰지 않으므로 의미가 없을 수 있음
+        pass
+
+    def rollback(self):
+        pass
+
+    def close(self):
+        # 기존 self.cursor, self.conn 닫아두기 (호환성)
+        if hasattr(self, 'cursor') and self.cursor:
+            self.cursor.close()
+        if hasattr(self, 'conn') and self.conn:
+            self.conn.close()
+
+    def load_sql(self, sql_file, directory="."):
+        if self.external_sql_path:
+            sql_path = f"{self.external_sql_path}/{directory}/{sql_file}"
+            if os.path.exists(sql_path):
+                with open(sql_path, 'r') as file:
+                    return file.read()
+            else:
+                raise FileNotFoundError(f"File not found: {sql_path}")
+        else:
+            raise RuntimeError("External sql directory not initialized.")
+
+    def keep_alive(self):
+        """
+        원래는 self.conn에 주기적으로 ping을 보내는 로직.
+        매번 새 커넥션을 쓰는 구조라면 필요 없어질 수 있음.
+        일단 기존 코드 유지, 실제로는 큰 효과가 없을 것.
+        """
+        while True:
+            sleep(self.keep_alive_interval)
+            try:
+                with self.conn.cursor() as cursor:
+                    cursor.execute("SELECT 1")
+            except pymysql.MySQLError as e:
+                print(f"Keep-alive query failed: {e}")
+                if e.args[0] == 2006:
+                    print("Reconnecting to the database for keep-alive...")
+                    self.reconnect()
+
+    def begin_transaction(self):
+        """
+        트랜잭션 컨텍스트를 생성하여 반환.
+        트랜잭션 내에서는 동일한 커넥션을 사용하므로,
+        여러 쿼리를 하나의 트랜잭션으로 묶을 수 있습니다.
+        """
+        return MySqlTransaction(self)
+
+class MySqlTransaction(Transaction):
+    def __init__(self, wrapper: MySqlWrapper):
+        self.wrapper = wrapper
+        self.conn = pymysql.connect(
+            host=wrapper.host,
+            user=wrapper.user,
+            password=wrapper.password,
+            db=wrapper.db,
+            port=wrapper.port,
+            cursorclass=DictCursor
+        )
+        self.cursor = self.conn.cursor()
+
+    def execute(self, query, params=None):
+        return self.cursor.execute(query, params)
+
+    def fetchall(self):
+        return self.cursor.fetchall()
+
+    def fetchone(self):
+        return self.cursor.fetchone()
+
+    def commit(self):
+        self.conn.commit()
+
+    def rollback(self):
+        self.conn.rollback()
+
+    def close(self):
+        self.cursor.close()
+        self.conn.close()
+
+    def __enter__(self):
+        return self  # Transaction 객체를 반환
+
+    def __exit__(self, exc_type, exc_val, traceback):
+        # 예외 발생 시 rollback, 그렇지 않으면 commit
+        if exc_type:
+            self.rollback()
+        else:
+            self.commit()
+        self.close()

sqloader-0.1.0/sqloader/sqlite3.py

@@ -0,0 +1,218 @@
+import sqlite3
+import threading
+from ._prototype import DatabasePrototype, Transaction, SQLITE
+
+query_semaphore = None
+
+db_lock = threading.Lock()
+
+class SQLiteWrapper(DatabasePrototype):
+    db_type = SQLITE
+
+    def __init__(self, db_name, memory_mode=False, max_parallel_queries=5):
+        self.db_name = db_name
+        self.memory_mode = memory_mode
+
+        global query_semaphore
+        query_semaphore = threading.Semaphore(max_parallel_queries)
+
+        if self.memory_mode:
+            # 인메모리: 단일 커넥션 + Lock
+            self.conn = sqlite3.connect(":memory:", check_same_thread=False)
+            self.cursor = self.conn.cursor()
+            # 만약 파일에서 데이터를 복사해야 한다면, 필요에 따라 아래 로직 사용
+            # backup_conn = sqlite3.connect(db_name)
+            # backup_conn.backup(self.conn)
+            # backup_conn.close()
+        else:
+            # 파일 모드: 나중에 세마포어 방식으로 새 커넥션을 여므로,
+            # 여기서 굳이 conn/cursor를 만들지 않아도 됩니다.
+            self.conn = None
+            self.cursor = None
+
+    def _execute_memory(self, query, params=None, commit=True):
+        """인메모리 모드 - 단일 커넥션 + Lock(직렬화)."""
+        with db_lock:
+            try:
+                if params is None:
+                    self.cursor.execute(query)
+                else:
+                    self.cursor.execute(query, params)
+                if commit:
+                    self.conn.commit()
+                return self.cursor.lastrowid
+            except sqlite3.DatabaseError as e:
+                print(f"Error executing query: {e}")
+                self.conn.rollback()
+                raise e
+
+    def _execute_file(self, query, params=None, commit=True):
+        """파일 모드 - 세마포어 + 새 커넥션(병렬 제한)."""
+        query_semaphore.acquire()
+        try:
+            conn = sqlite3.connect(self.db_name, check_same_thread=False)
+            cursor = conn.cursor()
+            try:
+                if params is None:
+                    cursor.execute(query)
+                else:
+                    cursor.execute(query, params)
+                if commit:
+                    conn.commit()
+                return cursor.lastrowid
+            except sqlite3.DatabaseError as e:
+                print(f"Error executing query (file mode): {e}")
+                conn.rollback()
+                raise e
+            finally:
+                cursor.close()
+                conn.close()
+        finally:
+            query_semaphore.release()
+
+    def execute(self, query, params=None, commit=True):
+        if self.memory_mode:
+            return self._execute_memory(query, params, commit)
+        else:
+            return self._execute_file(query, params, commit)
+
+    def fetch_one(self, query, params=None):
+        if self.memory_mode:
+            with db_lock:
+                try:
+                    if params is None:
+                        self.cursor.execute(query)
+                    else:
+                        self.cursor.execute(query, params)
+                    return self.cursor.fetchone()
+                except sqlite3.DatabaseError as e:
+                    print(f"Error fetching data (memory mode, fetch_one): {e}")
+                    raise e
+        else:
+            # 파일 모드: 별도 새 커넥션으로 fetch
+            query_semaphore.acquire()
+            try:
+                conn = sqlite3.connect(self.db_name, check_same_thread=False)
+                cursor = conn.cursor()
+                try:
+                    if params is None:
+                        cursor.execute(query)
+                    else:
+                        cursor.execute(query, params)
+                    return cursor.fetchone()
+                except sqlite3.DatabaseError as e:
+                    print(f"Error fetching data (file mode, fetch_one): {e}")
+                    raise e
+                finally:
+                    cursor.close()
+                    conn.close()
+            finally:
+                query_semaphore.release()
+
+    def fetch_all(self, query, params=None):
+        if self.memory_mode:
+            with db_lock:
+                try:
+                    if params is None:
+                        self.cursor.execute(query)
+                    else:
+                        self.cursor.execute(query, params)
+                    return self.cursor.fetchall()
+                except sqlite3.DatabaseError as e:
+                    print(f"Error fetching data (memory mode, fetch_all): {e}")
+                    raise e
+        else:
+            query_semaphore.acquire()
+            try:
+                conn = sqlite3.connect(self.db_name, check_same_thread=False)
+                cursor = conn.cursor()
+                try:
+                    if params is None:
+                        cursor.execute(query)
+                    else:
+                        cursor.execute(query, params)
+                    return cursor.fetchall()
+                except sqlite3.DatabaseError as e:
+                    print(f"Error fetching data (file mode, fetch_all): {e}")
+                    raise e
+                finally:
+                    cursor.close()
+                    conn.close()
+            finally:
+                query_semaphore.release()
+
+    def rollback(self):
+        if self.memory_mode:
+            with db_lock:
+                self.conn.rollback()
+        else:
+            # 파일 모드는 매번 새 커넥션을 쓰므로
+            # rollback할 '지속 커넥션'이 없습니다
+            pass
+
+    def commit(self):
+        if self.memory_mode:
+            with db_lock:
+                self.conn.commit()
+        else:
+            # 파일 모드는 매번 새 커넥션이므로 여기서 commit할 일이 없음
+            pass
+
+    def close(self):
+        if self.memory_mode:
+            with db_lock:
+                self.cursor.close()
+                self.conn.close()
+        else:
+            # 파일모드에선 conn이 따로 없으니 무처리
+            pass
+
+
+    def begin_transaction(self):
+        """
+        트랜잭션 컨텍스트를 생성하여 반환.
+        트랜잭션 내에서는 동일한 커넥션을 사용하므로,
+        여러 쿼리를 하나의 트랜잭션으로 묶을 수 있습니다.
+        """
+        return SQLiteTransaction(self)
+
+
+class SQLiteTransaction:
+    def __init__(self, wrapper: SQLiteWrapper):
+        self.wrapper = wrapper
+        self.conn = sqlite3.connect(
+            wrapper.db_name,
+            check_same_thread=False
+        )
+        self.cursor = self.conn.cursor()
+
+    def execute(self, query, params=None):
+        if params is None:
+            return self.cursor.execute(query)
+        return self.cursor.execute(query, params)
+
+    def fetchall(self):
+        return self.cursor.fetchall()
+
+    def fetchone(self):
+        return self.cursor.fetchone()
+
+    def commit(self):
+        self.conn.commit()
+
+    def rollback(self):
+        self.conn.rollback()
+
+    def close(self):
+        self.cursor.close()
+        self.conn.close()
+
+    def __enter__(self):
+        return self  # 컨텍스트 매니저 지원
+
+    def __exit__(self, exc_type, exc_val, traceback):
+        if exc_type:
+            self.rollback()
+        else:
+            self.commit()
+        self.close()

sqloader-0.1.0/sqloader/sqloader.py

@@ -0,0 +1,51 @@
+import json
+import os
+
+
+class SQLoader:
+
+    def __init__(self, dir) -> None:
+        self.sql_dir = dir
+
+    def check_file_exists(self, file_path):
+        return os.path.isfile(file_path)
+
+    def read_json_file(self, file_path):
+        if self.check_file_exists(file_path):
+            with open(file_path, 'r') as file:
+                return json.load(file)
+        else:
+            raise FileNotFoundError(f"File not found: {file_path}")
+
+    def read_sql_file(self, file_path, encode="utf-8"):
+        if self.check_file_exists(file_path):
+            with open(file_path, 'r', encoding=encode) as file:
+                return file.read()
+        else:
+            raise FileNotFoundError(f"File not found: {file_path}")
+
+    def deep_get(self, dictionary:dict, dotted_key:str):
+        keys = dotted_key.split(".")
+        for key in keys:
+            if isinstance(dictionary, dict):
+                dictionary = dictionary.get(key)
+            else:
+                return None
+        return dictionary
+
+    def load_sql(self, filename: str, query_name: str, encode="utf-8"):
+        suffix = ".json"
+        if suffix in filename:
+            suffix = ""
+        file_path = os.path.join(self.sql_dir, f"{filename}{suffix}")
+        queries = self.read_json_file(file_path)
+
+        query = self.deep_get(queries, query_name)
+        if query is None:
+            raise ValueError(f"Query not found: {query_name}")
+
+        if isinstance(query, str) and query.endswith('.sql'):
+            query_file_path = os.path.join(self.sql_dir, query)
+            return self.read_sql_file(query_file_path, encode)
+        else:
+            return query

sqloader-0.1.0/sqloader.egg-info/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: sqloader
+Version: 0.1.0
+Summary: A simple and extensible SQL migration and loader utility for Python.
+Home-page: https://github.com/horrible-gh/LogAssist.git
+Author: horrible-gh
+Author-email: horrible <shinjpn1@gmail.com>
+Project-URL: Homepage, https://github.com/horrible-gh/sqloader
+Project-URL: Bug Tracker, https://github.com/horrible-gh/sqloader/issues
+Keywords: sqloader,sql loader,migration,database migration,MySQL,SQLite,SQL migration,schema management,json sql loader
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: LogAssist
+Requires-Dist: pymysql
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# sqloader
+
+A lightweight Python utility for managing SQL migrations and loading SQL from JSON or .sql files.
+Supports common relational databases and is designed for simple, clean integration with any Python backend (e.g., FastAPI).
+
+---
+
+## Installation
+
+```powershell
+pip install sqloader
+```
+
+## Features
+
+- ✅ Easy database migration management
+- ✅ Load SQL queries from `.json` or `.sql` files
+- ✅ Supports MySQL and SQLite
+- ✅ Clean API for integration
+- ✅ Lightweight and dependency-minimized
+
+## Quickstart
+
+```python
+from sqloader.init import database_init
+
+config = {
+    "type": "mysql",
+    "mysql": {
+        "host": "localhost",
+        "port": 3306,
+        "user": "root",
+        "password": "pass",
+        "database": "mydb"
+    },
+    "service": {
+        "sqloder": "res/sql/sqloader/mysql"
+    },
+    "migration": {
+        "auto_migration": True,
+        "migration_path": "res/sql/migration/mysql"
+    },
+}
+
+db, sqloader, migrator = database_init(config)
+
+# Example usage
+query = sqloader.load_sql("user_info", "user.get_user_by_id")
+result = db.select_one(query, (123,))
+
+```
+
+## SQL Loading Behavior
+
+- If the value in the .json file ends with .sql, the referenced file will be loaded from the same directory.
+- Otherwise, the value is treated as a raw SQL string.
+
+Example JSON file user.json:
+
+
+```json
+{
+  "user": {
+    "get_user_by_id": "SELECT * FROM users WHERE id = %s",
+    "get_all_users": "user_all.sql"
+  },
+  "get_etc": "SELECT * FROM etc"
+}
+```

sqloader-0.1.0/sqloader.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+sqloader/__init__.py
+sqloader/_prototype.py
+sqloader/init.py
+sqloader/migrator.py
+sqloader/mysql.py
+sqloader/sqlite3.py
+sqloader/sqloader.py
+sqloader.egg-info/PKG-INFO
+sqloader.egg-info/SOURCES.txt
+sqloader.egg-info/dependency_links.txt
+sqloader.egg-info/requires.txt
+sqloader.egg-info/top_level.txt

sqloader-0.1.0/sqloader.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

sqloader-0.1.0/sqloader.egg-info/requires.txt

@@ -0,0 +1,2 @@
+LogAssist
+pymysql

sqloader-0.1.0/sqloader.egg-info/top_level.txt

@@ -0,0 +1 @@
+sqloader