reydb 1.1.52__py3-none-any.whl → 1.1.54__py3-none-any.whl

reydb/rbase.py

@@ -9,19 +9,28 @@
 """
 
 
-from typing import Any, TypedDict, Literal, overload
+from typing import Any, TypedDict, Literal
+from enum import EnumType
+from sqlalchemy import text as sqlalchemy_text
 from sqlalchemy.engine.base import Engine, Connection
 from sqlalchemy.engine.url import URL
 from sqlalchemy.sql.elements import TextClause
 from reykit.rbase import Base, throw
 from reykit.rre import search
 
+from reykit.rdata import to_json
+from reykit.rre import findall
+
 
 __all__ = (
     'DatabaseBase',
+    'handle_sql',
+    'handle_data',
     'extract_url',
     'extract_engine',
-    'extract_path'
+    'extract_path',
+    'get_syntax',
+    'is_multi_sql'
 )
 
 
@@ -47,6 +56,85 @@ class DatabaseBase(Base):
     """
 
 
+def handle_sql(sql: str | TextClause) -> TextClause:
+    """
+    Handle SQL.
+
+    Parameters
+    ----------
+    sql : SQL in method `sqlalchemy.text` format, or TextClause object.
+
+    Returns
+    -------
+    TextClause instance.
+    """
+
+    # Handle parameter.
+    if type(sql) == TextClause:
+        sql = sql.text
+
+    # Handle.
+    sql = sql.strip()
+    if sql[-1] != ';':
+        sql += ';'
+    sql = sqlalchemy_text(sql)
+
+    return sql
+
+
+def handle_data(data: list[dict], sql: str | TextClause) -> list[dict]:
+    """
+    Handle data based on the content of SQL.
+
+    Parameters
+    ----------
+    data : Data set for filling.
+    sql : SQL in method `sqlalchemy.text` format, or TextClause object.
+
+    Returns
+    -------
+    Filled data.
+    """
+
+    # Handle parameter.
+    if type(sql) == TextClause:
+        sql = sql.text
+
+    # Extract keys.
+    pattern = '(?<!\\\\):(\\w+)'
+    sql_keys = findall(pattern, sql)
+
+    # Extract keys of syntax "in".
+    pattern = '[iI][nN]\\s+(?<!\\\\):(\\w+)'
+    sql_keys_in = findall(pattern, sql)
+
+    # Loop.
+    for row in data:
+        if row == {}:
+            continue
+        for key in sql_keys:
+            value = row.get(key)
+
+            # Empty string.
+            if value == '':
+                value = None
+
+            # Convert.
+            elif (
+                type(value) in (list, dict)
+                and key not in sql_keys_in
+            ):
+                value = to_json(value)
+
+            # Enum.
+            elif isinstance(type(value), EnumType):
+                value = value.value
+
+            row[key] = value
+
+    return data
+
+
 def extract_url(url: str | URL) -> URLParameters:
     """
     Extract parameters from URL of string.

reydb/rconfig.py

@@ -17,7 +17,7 @@ from datetime import (
     time as Time,
     timedelta as Timedelta
 )
-from reykit.rbase import null, throw
+from reykit.rbase import Null, throw
 
 from .rdb import Database
 
@@ -445,10 +445,10 @@ class DatabaseConfig(object):
         """
 
         # Get.
-        value = self.get(key, null)
+        value = self.get(key, Null)
 
         # Check.
-        if value == null:
+        if value == Null:
             throw(KeyError, key)
 
         return value

reydb/rconn.py

@@ -10,7 +10,8 @@
 
 
 from typing import Self
-from sqlalchemy import Transaction
+from sqlalchemy import Connection, Transaction
+from sqlalchemy.ext.asyncio import AsyncConnection, AsyncTransaction
 
 from .rbase import DatabaseBase
 from .rdb import Database
@@ -18,6 +19,7 @@ from .rdb import Database
 
 __all__ = (
     'DatabaseConnection',
+    'DatabaseConnectionAsync'
 )
 
 
@@ -47,11 +49,44 @@ class DatabaseConnection(DatabaseBase):
         # Build.
         self.db = db
         self.autocommit = autocommit
-        self.conn = db.engine.connect()
-        self.exec = DatabaseExecute(self)
+        self.execute = DatabaseExecute(self)
+        self.conn: Connection | None = None
         self.begin: Transaction | None = None
 
 
+    def get_conn(self) -> Connection:
+        """
+        Get `Connection` instance.
+
+        Returns
+        -------
+        Instance.
+        """
+
+        # Create.
+        if self.conn is None:
+            self.conn = self.db.engine.connect()
+
+        return self.conn
+
+
+    def get_begin(self) -> Transaction:
+        """
+        Get `Transaction` instance.
+
+        Returns
+        -------
+        Instance.
+        """
+
+        # Create.
+        if self.begin is None:
+            conn = self.get_conn()
+            self.begin = conn.begin()
+
+        return self.begin
+
+
     def commit(self) -> None:
         """
         Commit cumulative executions.
@@ -80,7 +115,12 @@ class DatabaseConnection(DatabaseBase):
         """
 
         # Close.
-        self.conn.close()
+        if self.begin is not None:
+            self.begin.close()
+            self.begin = None
+        if self.conn is not None:
+            self.conn.close()
+            self.conn = None
 
 
     def __enter__(self) -> Self:
@@ -113,34 +153,163 @@ class DatabaseConnection(DatabaseBase):
             self.commit()
 
         # Close.
-        else:
-            self.close()
+        self.close()
 
 
-    __del__ = close
+    def insert_id(self) -> int:
+        """
+        Return last self increasing ID.
 
+        Returns
+        -------
+        ID.
+        """
 
-    @property
-    def execute(self):
+        # Get.
+        sql = 'SELECT LAST_INSERT_ID()'
+        result = self.execute(sql)
+        id_ = result.scalar()
+
+        return id_
+
+
+class DatabaseConnectionAsync(DatabaseBase):
+    """
+    Asynchronous database connection type.
+    """
+
+
+    def __init__(
+        self,
+        db: Database,
+        autocommit: bool
+    ) -> None:
+        """
+        Build instance attributes.
+
+        Parameters
+        ----------
+        db : `DatabaseAsync` instance.
+        autocommit: Whether automatic commit execute.
         """
-        Build `database execute` instance.
+
+        # Import.
+        from .rexec import DatabaseExecuteAsync
+
+        # Build.
+        self.db = db
+        self.autocommit = autocommit
+        self.aexecute = DatabaseExecuteAsync(self)
+        self.aconn: AsyncConnection | None = None
+        self.abegin: AsyncTransaction | None = None
+
+
+    async def get_conn(self) -> AsyncConnection:
+        """
+        Asynchronous get `Connection` instance.
 
         Returns
         -------
         Instance.
         """
 
-        # Create transaction.
-        if self.begin is None:
-            self.begin = self.conn.begin()
+        # Create.
+        if self.aconn is None:
+            self.aconn = await self.db.aengine.connect()
 
-        return self.exec
+        return self.aconn
 
 
-    @property
-    def insert_id(self) -> int:
+    async def get_begin(self) -> AsyncTransaction:
         """
-        Return last self increasing ID.
+        Asynchronous get `Transaction` instance.
+
+        Returns
+        -------
+        Instance.
+        """
+
+        # Create.
+        if self.abegin is None:
+            conn = await self.get_conn()
+            self.abegin = await conn.begin()
+
+        return self.abegin
+
+
+    async def commit(self) -> None:
+        """
+        Asynchronous commit cumulative executions.
+        """
+
+        # Commit.
+        if self.abegin is not None:
+            await self.abegin.commit()
+            self.abegin = None
+
+
+    async def rollback(self) -> None:
+        """
+        Asynchronous rollback cumulative executions.
+        """
+
+        # Rollback.
+        if self.abegin is not None:
+            await self.abegin.rollback()
+            self.abegin = None
+
+
+    async def close(self) -> None:
+        """
+        Asynchronous close database connection.
+        """
+
+        # Close.
+        if self.abegin is not None:
+            await self.abegin.close()
+            self.abegin = None
+        if self.aconn is not None:
+            await self.aconn.close()
+            self.aconn = None
+
+
+    async def __aenter__(self):
+        """
+        Asynchronous enter syntax `async with`.
+
+        Returns
+        -------
+        Self.
+        """
+
+        return self
+
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        *_
+    ) -> None:
+        """
+        Asynchronous exit syntax `async with`.
+
+        Parameters
+        ----------
+        exc_type : Exception type.
+        """
+
+        # Commit.
+        if exc_type is None:
+            await self.commit()
+
+        # Close.
+        await self.close()
+        await self.db.dispose()
+
+
+    async def insert_id(self) -> int:
+        """
+        Asynchronous return last self increasing ID.
 
         Returns
         -------
@@ -149,7 +318,7 @@ class DatabaseConnection(DatabaseBase):
 
         # Get.
         sql = 'SELECT LAST_INSERT_ID()'
-        result = self.execute(sql)
+        result = await self.aexecute(sql)
         id_ = result.scalar()
 
         return id_

reydb/rdb.py

@@ -9,10 +9,12 @@
 """
 
 
+from typing import Literal, Final, overload
 from urllib.parse import quote as urllib_quote
 from pymysql.constants.CLIENT import MULTI_STATEMENTS
 from sqlalchemy import create_engine as sqlalchemy_create_engine
 from sqlalchemy.engine.base import Engine
+from sqlalchemy.ext.asyncio import AsyncEngine, create_async_engine as sqlalchemy_create_async_engine
 from reykit.rtext import join_data_text
 
 from .rbase import DatabaseBase, extract_url
@@ -26,10 +28,6 @@ __all__ = (
 class Database(DatabaseBase):
     """
     Database type, based `MySQL`.
-
-    Attributes
-    ----------
-    default_report : Whether default to report execution.
     """
 
     default_report: bool = False
@@ -45,7 +43,7 @@ class Database(DatabaseBase):
         pool_size: int = 5,
         max_overflow: int = 10,
         pool_timeout: float = 30.0,
-        pool_recycle: int | None = None,
+        pool_recycle: int | None = 3600,
         **query: str
     ) -> None:
         """
@@ -62,10 +60,7 @@ class Database(DatabaseBase):
         max_overflow : Number of connections `allowed overflow`.
         pool_timeout : Number of seconds `wait create` connection.
         pool_recycle : Number of seconds `recycle` connection.
-            - `None`: Automatic select.
-                When is remote server database, then is database variable `wait_timeout` value.
-                When is local database file, then is `-1`.
-            - `Literal[-1]`: No recycle.
+            - `None | Literal[-1]`: No recycle.
             - `int`: Use this value.
         query : Remote server database parameters.
         """
@@ -90,14 +85,8 @@ class Database(DatabaseBase):
         self.query = query
 
         # Create engine.
-        self.engine = self.__create_engine()
-
-        # Server recycle time.
-        if pool_recycle is None:
-            wait_timeout = self.variables['wait_timeout']
-            if wait_timeout is not None:
-                self.pool_recycle = int(wait_timeout)
-            self.engine.pool._recycle = self.pool_recycle
+        self.engine = self.__create_engine(False)
+        self.aengine = self.__create_engine(True)
 
 
     @property
@@ -111,7 +100,8 @@ class Database(DatabaseBase):
         """
 
         # Get.
-        url_params = extract_url(self.url)
+        url = self.url(False)
+        url_params = extract_url(url)
         backend = url_params['backend']
 
         return backend
@@ -128,17 +118,57 @@ class Database(DatabaseBase):
         """
 
         # Get.
-        url_params = extract_url(self.url)
+        url = self.url(False)
+        url_params = extract_url(url)
         driver = url_params['driver']
 
         return driver
 
 
     @property
-    def url(self) -> str:
+    def abackend(self) -> str:
+        """
+        Asynchronous database backend name.
+
+        Returns
+        -------
+        Name.
+        """
+
+        # Get.
+        url = self.url(True)
+        url_params = extract_url(url)
+        backend = url_params['backend']
+
+        return backend
+
+
+    @property
+    def adriver(self) -> str:
+        """
+        Asynchronous database driver name.
+
+        Returns
+        -------
+        Name.
+        """
+
+        # Get.
+        url = self.url(True)
+        url_params = extract_url(url)
+        driver = url_params['driver']
+
+        return driver
+
+
+    def url(self, is_async: bool) -> str:
         """
         Generate server URL.
 
+        Parameters
+        ----------
+        is_async : Whether to use asynchronous engine.
+
         Returns
         -------
         Server URL.
@@ -146,7 +176,10 @@ class Database(DatabaseBase):
 
         # Generate URL.
         password = urllib_quote(self.password)
-        url_ = f'mysql+pymysql://{self.username}:{password}@{self.host}:{self.port}/{self.database}'
+        if is_async:
+            url_ = f'mysql+aiomysql://{self.username}:{password}@{self.host}:{self.port}/{self.database}'
+        else:
+            url_ = f'mysql+pymysql://{self.username}:{password}@{self.host}:{self.port}/{self.database}'
 
         # Add Server parameter.
         if self.query != {}:
@@ -161,18 +194,29 @@ class Database(DatabaseBase):
         return url_
 
 
-    def __create_engine(self) -> Engine:
+    @overload
+    def __create_engine(self, is_async: Literal[False]) -> Engine: ...
+
+    @overload
+    def __create_engine(self, is_async: Literal[True]) -> AsyncEngine: ...
+
+    def __create_engine(self, is_async: bool) -> Engine | AsyncEngine:
         """
         Create database `Engine` object.
 
+        Parameters
+        ----------
+        is_async : Whether to use asynchronous engine.
+
         Returns
         -------
         Engine object.
         """
 
         # Handle parameter.
+        url = self.url(is_async)
         engine_params = {
-            'url': self.url,
+            'url': url,
             'pool_size': self.pool_size,
             'max_overflow': self.max_overflow,
             'pool_timeout': self.pool_timeout,
@@ -181,23 +225,44 @@ class Database(DatabaseBase):
         }
 
         # Create Engine.
-        engine = sqlalchemy_create_engine(**engine_params)
+        if is_async:
+            engine = sqlalchemy_create_async_engine(**engine_params)
+        else:
+            engine = sqlalchemy_create_engine(**engine_params)
 
         return engine
 
 
-    @property
-    def count_conn(self) -> tuple[int, int]:
+    async def dispose(self) -> None:
+        """
+        Dispose asynchronous connections.
+        """
+
+        # Dispose.
+        await self.aengine.dispose()
+
+
+    def __conn_count(self, is_async: bool) -> tuple[int, int]:
         """
         Count number of keep open and allowed overflow connection.
 
+        Parameters
+        ----------
+        is_async : Whether to use asynchronous engine.
+
         Returns
         -------
         Number of keep open and allowed overflow connection.
         """
 
+        # Handle parameter.
+        if is_async:
+            engine = self.aengine
+        else:
+            engine = self.engine
+
         # Count.
-        _overflow = self.engine.pool._overflow
+        _overflow: int = engine.pool._overflow
         if _overflow < 0:
             keep_n = self.pool_size + _overflow
             overflow_n = 0
@@ -208,6 +273,38 @@ class Database(DatabaseBase):
         return keep_n, overflow_n
 
 
+    @property
+    def conn_count(self) -> tuple[int, int]:
+        """
+        Count number of keep open and allowed overflow connection.
+
+        Returns
+        -------
+        Number of keep open and allowed overflow connection.
+        """
+
+        # Count.
+        keep_n, overflow_n = self.__conn_count(False)
+
+        return keep_n, overflow_n
+
+
+    @property
+    def aconn_count(self) -> tuple[int, int]:
+        """
+        Count number of keep open and allowed overflow asynchronous connection.
+
+        Returns
+        -------
+        Number of keep open and allowed overflow asynchronous connection.
+        """
+
+        # Count.
+        keep_n, overflow_n = self.__conn_count(True)
+
+        return keep_n, overflow_n
+
+
     def schema(self, filter_default: bool = True) -> dict[str, dict[str, list[str]]]:
         """
         Get schemata of databases and tables and columns.
@@ -317,6 +414,45 @@ class Database(DatabaseBase):
         return exec
 
 
+    def aconnect(self, autocommit: bool = False):
+        """
+        Build `DatabaseConnectionAsync` instance.
+
+        Parameters
+        ----------
+        autocommit: Whether automatic commit execute.
+
+        Returns
+        -------
+        Database connection instance.
+        """
+
+        # Import.
+        from .rconn import DatabaseConnectionAsync
+
+        # Build.
+        conn = DatabaseConnectionAsync(self, autocommit)
+
+        return conn
+
+
+    @property
+    def aexecute(self):
+        """
+        Build `DatabaseConnectionAsync` instance.
+
+        Returns
+        -------
+        Instance.
+        """
+
+        # Build.
+        dbconn = self.aconnect(True)
+        exec = dbconn.aexecute
+
+        return exec
+
+
     @property
     def orm(self):
         """
@@ -546,7 +682,8 @@ class Database(DatabaseBase):
             for key, value in self.__dict__.items()
             if key not in filter_key
         }
-        info['count'] = self.count_conn
+        info['conn_count'] = self.conn_count
+        info['aconn_count'] = self.aconn_count
         text = join_data_text(info)
 
         return text