reykit 1.0.1__py3-none-any.whl → 1.1.0__py3-none-any.whl

reydb/rconnection.py

@@ -1,2276 +0,0 @@
-# !/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-"""
-@Time    : 2022-12-05 14:10:02
-@Author  : Rey
-@Contact : reyxbo@163.com
-@Explain : Database connection methods.
-"""
-
-
-from __future__ import annotations
-from typing import Any, Union, Optional, Literal, NoReturn, Self, overload, override
-from types import TracebackType
-from collections.abc import Iterable, Generator
-from urllib.parse import quote as urllib_quote
-from sqlalchemy import create_engine as sqlalchemy_create_engine, text
-from sqlalchemy.engine.base import Engine, Connection
-from sqlalchemy.engine.cursor import CursorResult
-from sqlalchemy.engine.url import URL
-from sqlalchemy.sql.elements import TextClause
-from sqlalchemy.exc import OperationalError
-from pandas import DataFrame
-from reykit.rdata import objs_in, RGenerator
-from reykit.rexception import throw
-from reykit.rmonkey import monkey_patch_sqlalchemy_result_more_fetch, monkey_patch_sqlalchemy_row_index_field
-from reykit.rregex import search, findall
-from reykit.rstdout import echo
-from reykit.rsystem import get_first_notnull
-from reykit.rtable import Table, to_table
-from reykit.rtext import join_data_text, to_json
-from reykit.rwrap import wrap_runtime, wrap_retry
-
-
-__all__ = (
-    'RResult',
-    'RDatabase',
-    'RDBConnection'
-)
-
-
-# Monkey path.
-monkey_result_type = monkey_patch_sqlalchemy_result_more_fetch()
-RResult = monkey_result_type
-monkey_patch_sqlalchemy_row_index_field()
-
-
-class RDatabase(object):
-    """
-    Rey's `database` type.
-    """
-
-
-    # Values to be converted to 'NULL'.
-    nulls: tuple = ('', ' ', b'', [], (), {}, set())
-
-    # Default value.
-    default_report: bool = False
-
-
-    @overload
-    def __init__(
-        self,
-        host: None = None,
-        port: Optional[Union[str, int]] = None,
-        username: Optional[str] = None,
-        password: Optional[str] = None,
-        database: Optional[str] = None,
-        drivername: Optional[str] = None,
-        pool_size: int = 5,
-        max_overflow: int = 10,
-        pool_timeout: float = 30.0,
-        pool_recycle: Optional[int] = None,
-        retry: bool = False,
-        url: None = None,
-        engine: None = None,
-        **query: str
-    ) -> NoReturn: ...
-
-    @overload
-    def __init__(
-        self,
-        host: Optional[str] = None,
-        port: None = None,
-        username: Optional[str] = None,
-        password: Optional[str] = None,
-        database: Optional[str] = None,
-        drivername: Optional[str] = None,
-        pool_size: int = 5,
-        max_overflow: int = 10,
-        pool_timeout: float = 30.0,
-        pool_recycle: Optional[int] = None,
-        retry: bool = False,
-        url: None = None,
-        engine: None = None,
-        **query: str
-    ) -> NoReturn: ...
-
-    @overload
-    def __init__(
-        self,
-        host: Optional[str] = None,
-        port: Optional[Union[str, int]] = None,
-        username: None = None,
-        password: Optional[str] = None,
-        database: Optional[str] = None,
-        drivername: Optional[str] = None,
-        pool_size: int = 5,
-        max_overflow: int = 10,
-        pool_timeout: float = 30.0,
-        pool_recycle: Optional[int] = None,
-        retry: bool = False,
-        url: None = None,
-        engine: None = None,
-        **query: str
-    ) -> NoReturn: ...
-
-    @overload
-    def __init__(
-        self,
-        host: Optional[str] = None,
-        port: Optional[Union[str, int]] = None,
-        username: Optional[str] = None,
-        password: None = None,
-        database: Optional[str] = None,
-        drivername: Optional[str] = None,
-        pool_size: int = 5,
-        max_overflow: int = 10,
-        pool_timeout: float = 30.0,
-        pool_recycle: Optional[int] = None,
-        retry: bool = False,
-        url: None = None,
-        engine: None = None,
-        **query: str
-    ) -> NoReturn: ...
-
-    @overload
-    def __init__(
-        self,
-        host: Optional[str] = None,
-        port: Optional[Union[str, int]] = None,
-        username: Optional[str] = None,
-        password: Optional[str] = None,
-        database: Optional[str] = None,
-        drivername: Optional[str] = None,
-        pool_size: int = 5,
-        max_overflow: int = 10,
-        pool_timeout: float = 30.0,
-        pool_recycle: Optional[int] = None,
-        retry: bool = False,
-        url: Optional[Union[str, URL]] = None,
-        engine: Optional[Union[Engine, Connection]] = None,
-        **query: str
-    ) -> None: ...
-
-    def __init__(
-        self,
-        host: Optional[str] = None,
-        port: Optional[Union[str, int]] = None,
-        username: Optional[str] = None,
-        password: Optional[str] = None,
-        database: Optional[str] = None,
-        drivername: Optional[str] = None,
-        pool_size: int = 5,
-        max_overflow: int = 10,
-        pool_timeout: float = 30.0,
-        pool_recycle: Optional[int] = None,
-        retry: bool = False,
-        url: Optional[Union[str, URL]] = None,
-        engine: Optional[Union[Engine, Connection]] = None,
-        **query: str
-    ) -> None:
-        """
-        Build `database` attributes.
-
-        Parameters
-        ----------
-        host : Server host.
-        port : Server port.
-        username : Server username.
-        password : Server password.
-        database : Database name in the server.
-        drivername : Database backend and driver name.
-            - `None`: Automatic select and try.
-            - `str`: Use this value.
-        pool_size : Number of connections `keep open`.
-        max_overflow : Number of connections `allowed overflow`.
-        pool_timeout : Number of seconds `wait create` connection.
-        pool_recycle : Number of seconds `recycle` connection.
-            - `None`, Use database variable `wait_timeout`: value.
-            - `Literal[-1]`: No recycle.
-            - `int`: Use this value.
-        retry : Whether retry execute.
-        url: Get parameter from server `URL`, but preferred input parameters.
-            Parameters include `username`, `password`, `host`, `port`, `database`, `drivername`, `query`.
-        engine : Use existing `Engine` or `Connection` object, and get parameter from it.
-            Parameters include `username`, `password`, `host`, `port`, `database`, `drivername`, `query`,
-            `pool_size`, `max_overflow`, `pool_timeout`, `pool_recycle`.
-        query : Server parameters.
-        """
-
-        # Handle parameter.
-        if port.__class__ == int:
-            port = str(port)
-
-        # Set attribute.
-        self.retry = retry
-
-        # From existing Engine or Connection object.
-        if engine is not None:
-
-            ## Extract Engine object from Connection boject.
-            if engine.__class__ == Connection:
-                engine = engine.engine
-
-            ## Extract parameter.
-            params = self.extract_engine(engine)
-
-            ## Set.
-            self.drivername: str = params['drivername']
-            self.username: str = params['username']
-            self.password: str = params['password']
-            self.host: str = params['host']
-            self.port: str = params['port']
-            self.database: Optional[str] = params['database']
-            self.query: dict = params['query']
-            self.pool_size: int = params['pool_size']
-            self.max_overflow: int = params['max_overflow']
-            self.pool_timeout: float = params['pool_timeout']
-            self.pool_recycle: int = params['pool_recycle']
-            self.engine = engine
-
-        # From parameters create.
-        else:
-
-            ## Extract parameters from URL.
-            if url is not None:
-                params = self.extract_url(url)
-            else:
-                params = dict.fromkeys(
-                    (
-                        'drivername',
-                        'username',
-                        'password',
-                        'host',
-                        'port',
-                        'database',
-                        'query'
-                    )
-                )
-
-            ## Set parameters by priority.
-            self.drivername: str = get_first_notnull(drivername, params['drivername'])
-            self.username: str = get_first_notnull(username, params['username'], default='exception')
-            self.password: str = get_first_notnull(password, params['password'], default='exception')
-            self.host: str = get_first_notnull(host, params['host'], default='exception')
-            self.port: str = get_first_notnull(port, params['port'], default='exception')
-            self.database: Optional[str] = get_first_notnull(database, params['database'])
-            self.query: dict = get_first_notnull(query, params['query'])
-            self.pool_size = pool_size
-            self.max_overflow = max_overflow
-            self.pool_timeout = pool_timeout
-
-            ## Create Engine object.
-            if pool_recycle is None:
-                self.pool_recycle = -1
-                self.engine = self.create_engine()
-                wait_timeout = int(self.variables['wait_timeout'])
-                self.pool_recycle = wait_timeout
-                self.engine.pool._recycle = wait_timeout
-            else:
-                self.pool_recycle = pool_recycle
-                self.engine = self.create_engine()
-
-
-    def extract_url(self, url: Union[str, URL]) -> dict[
-        Literal['drivername', 'username', 'password', 'host', 'port', 'database', 'query'],
-        Any
-    ]:
-        """
-        Extract parameters from URL of string.
-
-        Parameters
-        ----------
-        url : URL of string.
-
-        Returns
-        -------
-        Extracted parameters.
-        """
-
-        # Extract.
-        match url:
-
-            ## When str object.
-            case str():
-                pattern = r'^([\w\+]+)://(\w+):(\w+)@(\d+\.\d+\.\d+\.\d+):(\d+)[/]?([\w/]+)?[\?]?([\w&=]+)?$'
-                result = search(pattern, url)
-                if result is None:
-                    throw(ValueError, url)
-                (
-                    drivername,
-                    username,
-                    password,
-                    host,
-                    port,
-                    database,
-                    query_str
-                ) = result
-                if query_str is not None:
-                    pattern = r'(\w+)=(\w+)'
-                    query_findall = findall(pattern, query_str)
-                    query = {key: value for key, value in query_findall}
-                else:
-                    query = {}
-
-            ## When URL object.
-            case URL():
-                drivername = url.drivername
-                username = url.username
-                password = url.password
-                host = url.host
-                port = url.port
-                database = url.database
-                query = dict(url.query)
-
-        # Generate parameter.
-        params = {
-            'drivername': drivername,
-            'username': username,
-            'password': password,
-            'host': host,
-            'port': port,
-            'database': database,
-            'query': query
-        }
-
-        return params
-
-
-    def extract_engine(self, engine: Union[Engine, Connection]) -> dict[
-        Literal[
-            'drivername', 'username', 'password', 'host', 'port', 'database', 'query',
-            'pool_size', 'max_overflow', 'pool_timeout', 'pool_recycle'
-        ],
-        Any
-    ]:
-        """
-        Extract parameters from `Engine` or `Connection` object.
-
-        Parameters
-        ----------
-        engine : Engine or Connection object.
-
-        Returns
-        -------
-        Extracted parameters.
-        """
-
-        ## Extract Engine object from Connection boject.
-        if engine.__class__ == Connection:
-            engine = engine.engine
-
-        ## Extract.
-        drivername = engine.url.drivername
-        username = engine.url.username
-        password = engine.url.password
-        host = engine.url.host
-        port = engine.url.port
-        database = engine.url.database
-        query = dict(engine.url.query)
-        pool_size = engine.pool._pool.maxsize
-        max_overflow = engine.pool._max_overflow
-        pool_timeout = engine.pool._timeout
-        pool_recycle = engine.pool._recycle
-
-        # Generate parameter.
-        params = {
-            'drivername': drivername,
-            'username': username,
-            'password': password,
-            'host': host,
-            'port': port,
-            'database': database,
-            'query': query,
-            'pool_size': pool_size,
-            'max_overflow': max_overflow,
-            'pool_timeout': pool_timeout,
-            'pool_recycle': pool_recycle
-        }
-
-        return params
-
-
-    @overload
-    def extract_path(
-        self,
-        path: str,
-        main: Literal['table'] = 'table'
-    ) -> tuple[Optional[str], str, Optional[str]]: ...
-
-    @overload
-    def extract_path(
-        self,
-        path: str,
-        main: Literal['database'] = 'table'
-    ) -> tuple[str, Optional[str], Optional[str]]: ...
-
-    def extract_path(
-        self,
-        path: str,
-        main: Literal['table', 'database'] = 'table'
-    ) -> tuple[Optional[str], Optional[str], Optional[str]]:
-        """
-        Extract table name and database name and column name from path.
-
-        Parameters
-        ----------
-        path : Automatic extract.
-            ```Not contain '.' or contain '`'```: Main name.
-            `Contain '.'`: Database name and table name, column name is optional. Example 'database.table[.column]'.
-        main : Priority main name, 'table' or 'database'.
-
-        Returns
-        -------
-        Database name and table name and column name.
-        """
-
-        # Extract.
-        if (
-            '.' not in path
-            or '`' in path
-        ):
-            name = path.replace('`', '')
-            match main:
-                case 'table':
-                    names = (None, name, None)
-                case 'database':
-                    names = (name, None, None)
-                case _:
-                    throw(ValueError, main)
-        else:
-            names = path.split('.', 2)
-            if len(names) == 2:
-                names.append(None)
-            names = tuple(names)
-
-        return names
-
-
-    @property
-    def url(self) -> str:
-        """
-        Generate server URL.
-
-        Returns
-        -------
-        Server URL.
-        """
-
-        # Generate URL.
-        password = urllib_quote(self.password)
-        _url = f'{self.drivername}://{self.username}:{password}@{self.host}:{self.port}'
-
-        # Add database path.
-        if self.database is not None:
-            _url = f'{_url}/{self.database}'
-
-        # Add Server parameter.
-        if self.query != {}:
-            query = '&'.join(
-                [
-                    f'{key}={value}'
-                    for key, value in self.query.items()
-                ]
-            )
-            _url = f'{_url}?{query}'
-
-        return _url
-
-
-    def create_engine(self, **kwargs) -> Engine:
-        """
-        Create database `Engine` object.
-
-        Parameters
-        ----------
-        kwargs : Keyword arguments of create engine method.
-
-        Returns
-        -------
-        Engine object.
-        """
-
-        # Handle parameter.
-        if self.drivername is None:
-            drivernames = ('mysql+mysqldb', 'mysql+pymysql', 'mysql+mysqlconnector')
-        else:
-            drivernames = (self.drivername,)
-
-        # Create Engine object.
-        for drivername in drivernames:
-
-            ## Set engine parameter.
-            self.drivername = drivername
-            engine_params = {
-                'url': self.url,
-                'pool_size': self.pool_size,
-                'max_overflow': self.max_overflow,
-                'pool_timeout': self.pool_timeout,
-                'pool_recycle': self.pool_recycle,
-                **kwargs
-            }
-
-            ## Try create.
-            try:
-                engine = sqlalchemy_create_engine(**engine_params)
-            except ModuleNotFoundError:
-                pass
-            else:
-                return engine
-
-        # Throw exception.
-        drivernames_str = ' and '.join(
-            [
-                "'%s'" % dirvername.split('+', 1)[-1]
-                for dirvername in drivernames
-            ]
-        )
-        raise ModuleNotFoundError(f'module {drivernames_str} not fund')
-
-
-    @property
-    def count(self) -> tuple[int, int]:
-        """
-        Count number of keep open and allowed overflow connection.
-
-        Returns
-        -------
-        Number of keep open and allowed overflow connection.
-        """
-
-        # Get parameter.
-        if hasattr(self, 'engine'):
-            rdatabase = self
-        else:
-            rdatabase: RDatabase = self.rdatabase
-
-        # Count.
-        _overflow = rdatabase.engine.pool._overflow
-        if _overflow < 0:
-            keep_n = rdatabase.pool_size + _overflow
-            overflow_n = 0
-        else:
-            keep_n = rdatabase.pool_size
-            overflow_n = _overflow
-
-        return keep_n, overflow_n
-
-
-    def handle_data(
-        self,
-        data: Table,
-        sql: Union[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.
-        match data:
-            case dict():
-                data = [data]
-            case list():
-                data = to_table(data)
-        if sql.__class__ == 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)
-
-                # Fill.
-                if (
-                    value is None
-                    or value in self.nulls
-                ):
-                    row[key] = None
-
-                # Convert.
-                elif (
-                    value.__class__ in (list, dict)
-                    and key not in sql_keys_in
-                ):
-                    value= to_json(value)
-                    row[key] = value
-
-        return data
-
-
-    def get_syntax(self, sql: Union[str, TextClause]) -> list[str]:
-        """
-        Extract SQL syntax type for each segment form SQL.
-
-        Parameters
-        ----------
-        sql : SQL text or TextClause object.
-
-        Returns
-        -------
-        SQL syntax type for each segment.
-        """
-
-        # Handle parameter.
-        if sql.__class__ == TextClause:
-            sql = sql.text
-
-        # Extract.
-        syntax = [
-            search('[a-zA-Z]+', sql_part).upper()
-            for sql_part in sql.split(';')
-        ]
-
-        return syntax
-
-
-    def is_multi_sql(self, sql: Union[str, TextClause]) -> bool:
-        """
-        Judge whether it is multi segment SQL.
-
-        Parameters
-        ----------
-        sql : SQL text or TextClause object.
-
-        Returns
-        -------
-        Judgment result.
-        """
-
-        # Handle parameter.
-        if sql.__class__ == TextClause:
-            sql = sql.text
-
-        # Judge.
-        if ';' in sql.rstrip()[:-1]:
-            return True
-        return False
-
-
-    def executor(
-        self,
-        connection: Connection,
-        sql: TextClause,
-        data: list[dict],
-        report: bool
-    ) -> RResult:
-        """
-        SQL executor.
-
-        Parameters
-        ----------
-        connection : Connection object.
-        sql : TextClause object.
-        data : Data set for filling.
-        report : Whether report SQL execute information.
-
-        Returns
-        -------
-        Result object.
-        """
-
-        # Create Transaction object.
-        with connection.begin():
-
-            # Execute.
-
-            ## Report.
-            if report:
-                result, report_runtime = wrap_runtime(connection.execute, sql, data, _return_report=True)
-                report_info = (
-                    f'{report_runtime}\n'
-                    f'Row Count: {result.rowcount}'
-                )
-                sqls = [
-                    sql_part.strip()
-                    for sql_part in sql.text.split(';')
-                ]
-                if data == []:
-                    echo(report_info, *sqls, title='SQL')
-                else:
-                    echo(report_info, *sqls, data, title='SQL')
-
-            ## Not report.
-            else:
-                result = connection.execute(sql, data)
-
-        return result
-
-
-    def execute(
-        self,
-        sql: Union[str, TextClause],
-        data: Optional[Table] = None,
-        report: Optional[bool] = None,
-        **kwdata: Any
-    ) -> RResult:
-        """
-        Execute SQL.
-
-        Parameters
-        ----------
-        sql : SQL in method `sqlalchemy.text` format, or `TextClause` object.
-        data : Data set for filling.
-        report : Whether report SQL execute information.
-            - `None`: Use attribute `default_report`.
-            - `bool`: Use this value.
-        kwdata : Keyword parameters for filling.
-
-        Returns
-        -------
-        Result object.
-        """
-
-        # Get parameter by priority.
-        report = get_first_notnull(report, self.default_report, default='exception')
-
-        # Handle parameter.
-        if sql.__class__ == str:
-            sql = text(sql)
-        if data is None:
-            if kwdata == {}:
-                data = []
-            else:
-                data = [kwdata]
-        else:
-            match data:
-                case dict():
-                    data = [data]
-                case CursorResult():
-                    data = to_table(data)
-                case DataFrame():
-                    data = to_table(data)
-                case _:
-                    data = data.copy()
-            for param in data:
-                param.update(kwdata)
-
-        # Handle data.
-        data = self.handle_data(data, sql)
-
-        # Execute.
-
-        ## Create Connection object.
-        with self.engine.connect() as connection:
-
-            ## Can retry.
-            if (
-                self.retry
-                and not self.is_multi_sql(sql)
-            ):
-                result = wrap_retry(
-                    self.executor,
-                    connection,
-                    sql,
-                    data,
-                    report,
-                    _report='Database Execute Operational Error',
-                    _exception=OperationalError
-                )
-
-            ## Cannot retry.
-            else:
-                result = self.executor(connection, sql, data, report)
-
-        return result
-
-
-    def execute_select(
-        self,
-        path: Union[str, tuple[str, str]],
-        fields: Optional[Union[str, Iterable[str]]] = None,
-        where: Optional[str] = None,
-        group: Optional[str] = None,
-        having: Optional[str] = None,
-        order: Optional[str] = None,
-        limit: Optional[Union[int, str, tuple[int, int]]] = None,
-        report: Optional[bool] = None,
-        **kwdata: Any
-    ) -> RResult:
-        """
-        Execute select SQL.
-
-        Parameters
-        ----------
-        path : Table name, can contain database name, otherwise use `self.database`.
-            - `str`: Automatic extract database name and table name.
-            - `tuple[str, str]`: Database name and table name.
-        fields : Select clause content.
-            - `None`: Is `SELECT *`.
-            - `str`: Join as `SELECT str`.
-            - `Iterable[str]`, Join as `SELECT ``str``: ...`.
-                `str and first character is ':'`: Use this syntax.
-                `str`: Use this field.
-        where : Clause `WHERE` content, join as `WHERE str`.
-        group : Clause `GROUP BY` content, join as `GROUP BY str`.
-        having : Clause `HAVING` content, join as `HAVING str`.
-        order : Clause `ORDER BY` content, join as `ORDER BY str`.
-        limit : Clause `LIMIT` content.
-            - `Union[int, str]`: Join as `LIMIT int/str`.
-            - `tuple[int, int]`: Join as `LIMIT int, int`.
-        report : Whether report SQL execute information.
-            - `None`, Use attribute `report_execute_info`: of object `ROption`.
-            - `int`: Use this value.
-        kwdata : Keyword parameters for filling.
-
-        Returns
-        -------
-        Result object.
-
-        Examples
-        --------
-        Parameter `fields`.
-        >>> fields = ['id', ':`id` + 1 AS `id_`']
-        >>> result = RDatabase.execute_select('database.table', fields)
-        >>> print(result.to_table())
-        [{'id': 1, 'id_': 2}, ...]
-
-        Parameter `kwdata`.
-        >>> fields = '`id`, `id` + :value AS `id_`'
-        >>> result = RDatabase.execute_select('database.table', fields, value=1)
-        >>> print(result.to_table())
-        [{'id': 1, 'id_': 2}, ...]
-        """
-
-        # Handle parameter.
-        if path.__class__ == str:
-            database, table, _ = self.extract_path(path)
-        else:
-            database, table = path
-
-        # Get parameter by priority.
-        database = get_first_notnull(database, self.database, default='exception')
-
-        # Generate SQL.
-        sql_list = []
-
-        ## Part 'SELECT' syntax.
-        if fields is None:
-            fields = '*'
-        elif fields.__class__ != str:
-            fields = ', '.join(
-                [
-                    field[1:]
-                    if (
-                        field.startswith(':')
-                        and field != ':'
-                    )
-                    else f'`{field}`'
-                    for field in fields
-                ]
-            )
-        sql_select = f'SELECT {fields}'
-        sql_list.append(sql_select)
-
-        ## Part 'FROM' syntax.
-        sql_from = f'FROM `{database}`.`{table}`'
-        sql_list.append(sql_from)
-
-        ## Part 'WHERE' syntax.
-        if where is not None:
-            sql_where = f'WHERE {where}'
-            sql_list.append(sql_where)
-
-        ## Part 'GROUP BY' syntax.
-        if group is not None:
-            sql_group = f'GROUP BY {group}'
-            sql_list.append(sql_group)
-
-        ## Part 'GROUP BY' syntax.
-        if having is not None:
-            sql_having = f'HAVING {having}'
-            sql_list.append(sql_having)
-
-        ## Part 'ORDER BY' syntax.
-        if order is not None:
-            sql_order = f'ORDER BY {order}'
-            sql_list.append(sql_order)
-
-        ## Part 'LIMIT' syntax.
-        if limit is not None:
-            if limit.__class__ in (str, int):
-                sql_limit = f'LIMIT {limit}'
-            else:
-                if len(limit) == 2:
-                    sql_limit = f'LIMIT {limit[0]}, {limit[1]}'
-                else:
-                    throw(ValueError, limit)
-            sql_list.append(sql_limit)
-
-        ## Join sql part.
-        sql = '\n'.join(sql_list)
-
-        # Execute SQL.
-        result = self.execute(sql, report=report, **kwdata)
-
-        return result
-
-
-    def execute_insert(
-        self,
-        path: Union[str, tuple[str, str]],
-        data: Table,
-        duplicate: Optional[Literal['ignore', 'update']] = None,
-        report: Optional[bool] = None,
-        **kwdata: Any
-    ) -> RResult:
-        """
-        Insert the data of table in the datebase.
-
-        Parameters
-        ----------
-        path : Table name, can contain database name, otherwise use `self.database`.
-            - `str`: Automatic extract database name and table name.
-            - `tuple[str, str]`: Database name and table name.
-        data : Insert data.
-        duplicate : Handle method when constraint error.
-            - `None`: Not handled.
-            - `ignore`, Use `UPDATE IGNORE INTO`: clause.
-            - `update`, Use `ON DUPLICATE KEY UPDATE`: clause.
-        report : Whether report SQL execute information.
-            - `None`, Use attribute `report_execute_info`: of object `ROption`.
-            - `int`: Use this value.
-        kwdata : Keyword parameters for filling.
-            - `str and first character is ':'`: Use this syntax.
-            - `Any`: Use this value.
-
-        Returns
-        -------
-        Result object.
-
-        Examples
-        --------
-        Parameter `data` and `kwdata`.
-        >>> data = [{'key': 'a'}, {'key': 'b'}]
-        >>> kwdata = {'value1': 1, 'value2': ':(SELECT 2)'}
-        >>> result = RDatabase.execute_insert('database.table', data, **kwdata)
-        >>> print(result.rowcount)
-        2
-        >>> result = RDatabase.execute_select('database.table')
-        >>> print(result.to_table())
-        [{'key': 'a', 'value1': 1, 'value2': 2}, {'key': 'b', 'value1': 1, 'value2': 2}]
-        """
-
-        # Handle parameter.
-        if path.__class__ == str:
-            database, table, _ = self.extract_path(path)
-        else:
-            database, table = path
-
-        # Get parameter by priority.
-        database = get_first_notnull(database, self.database, default='exception')
-
-        # Handle parameter.
-
-        ## Data.
-        match data:
-            case dict():
-                data = [data]
-            case CursorResult():
-                data = to_table(data)
-            case DataFrame():
-                data = to_table(data)
-
-        ## Check.
-        if data in ([], [{}]):
-            throw(ValueError, data)
-
-        ## Keyword data.
-        kwdata_method = {}
-        kwdata_replace = {}
-        for key, value in kwdata.items():
-            if (
-                value.__class__ == str
-                and value.startswith(':')
-                and value != ':'
-            ):
-                kwdata_method[key] = value[1:]
-            else:
-                kwdata_replace[key] = value
-
-        # Generate SQL.
-
-        ## Part 'fields' syntax.
-        fields_replace = {
-            field
-            for row in data
-            for field in row
-        }
-        fields_replace = {
-            field
-            for field in fields_replace
-            if field not in kwdata
-        }
-        sql_fields_list = (
-            *kwdata_method,
-            *kwdata_replace,
-            *fields_replace
-        )
-        sql_fields = ', '.join(
-            [
-                f'`{field}`'
-                for field in sql_fields_list
-            ]
-        )
-
-        ## Part 'values' syntax.
-        sql_values_list = (
-            *kwdata_method.values(),
-            *[
-                ':' + field
-                for field in (
-                    *kwdata_replace,
-                    *fields_replace
-                )
-            ]
-        )
-        sql_values = ', '.join(sql_values_list)
-
-        ## Join sql part.
-        match duplicate:
-
-            ### Ignore.
-            case 'ignore':
-                sql = (
-                    f'INSERT IGNORE INTO `{database}`.`{table}`({sql_fields})\n'
-                    f'VALUES({sql_values})'
-                )
-
-            ### Update.
-            case 'update':
-                update_content = ',\n    '.join([f'`{field}` = VALUES(`{field}`)' for field in sql_fields_list])
-                sql = (
-                    f'INSERT INTO `{database}`.`{table}`({sql_fields})\n'
-                    f'VALUES({sql_values})\n'
-                    'ON DUPLICATE KEY UPDATE\n'
-                    f'    {update_content}'
-                )
-
-            ### Not handle.
-            case _:
-                sql = (
-                    f'INSERT INTO `{database}`.`{table}`({sql_fields})\n'
-                    f'VALUES({sql_values})'
-                )
-
-        # Execute SQL.
-        result = self.execute(sql, data, report, **kwdata_replace)
-
-        return result
-
-
-    def execute_update(
-        self,
-        path: Union[str, tuple[str, str]],
-        data: Table,
-        where_fields: Optional[Union[str, Iterable[str]]] = None,
-        report: Optional[bool] = None,
-        **kwdata: Any
-    ) -> RResult:
-        """
-        Update the data of table in the datebase.
-
-        Parameters
-        ----------
-        path : Table name, can contain database name, otherwise use `self.database`.
-            - `str`: Automatic extract database name and table name.
-            - `tuple[str, str]`: Database name and table name.
-        data : Update data, clause `SET` and `WHERE` and `ORDER BY` and `LIMIT` content.
-            - `Key`: Table field.
-                `literal['order']`: Clause `ORDER BY` content, join as `ORDER BY str`.
-                `literal['limit']`: Clause `LIMIT` content, join as `LIMIT str`.
-                `Other`: Clause `SET` and `WHERE` content.
-            - `Value`: Table value.
-                `Union[list, tuple]`: Join as `field IN :str`.
-                `Any`: Join as `field = :str`.
-        where_fields : Clause `WHERE` content fields.
-            - `None`: The first key value pair of each item is judged.
-            - `str`: This key value pair of each item is judged.
-            - `Iterable[str]` Multiple judged, `and`: relationship.
-        report : Whether report SQL execute information.
-            - `None`, Use attribute `report_execute_info`: of object `ROption`.
-            - `int`: Use this value.
-        kwdata : Keyword parameters for filling.
-            - `str and first character is ':'`: Use this syntax.
-            - `Any`: Use this value.
-
-        Returns
-        -------
-        Result object.
-
-        Examples
-        --------
-        Parameter `data` and `kwdata`.
-        >>> data = [{'key': 'a'}, {'key': 'b'}]
-        >>> kwdata = {'value': 1, 'name': ':`key`'}
-        >>> result = RDatabase.execute_update('database.table', data, **kwdata)
-        >>> print(result.rowcount)
-        2
-        >>> result = RDatabase.execute_select('database.table')
-        >>> print(result.to_table())
-        [{'key': 'a', 'value': 1, 'name': 'a'}, {'key': 'b', 'value': 1, 'name': 'b'}]
-        """
-
-        # Handle parameter.
-        if path.__class__ == str:
-            database, table, _ = self.extract_path(path)
-        else:
-            database, table = path
-
-        # Get parameter by priority.
-        database = get_first_notnull(database, self.database, default='exception')
-
-        # Handle parameter.
-
-        ## Data.
-        match data:
-            case dict():
-                data = [data]
-            case CursorResult():
-                data = to_table(data)
-            case DataFrame():
-                data = to_table(data)
-
-        ## Check.
-        if data in ([], [{}]):
-            throw(ValueError, data)
-
-        ## Keyword data.
-        kwdata_method = {}
-        kwdata_replace = {}
-        for key, value in kwdata.items():
-            if (
-                value.__class__ == str
-                and value.startswith(':')
-                and value != ':'
-            ):
-                kwdata_method[key] = value[1:]
-            else:
-                kwdata_replace[key] = value
-        sql_set_list_kwdata = [
-            f'`{key}` = {value}'
-            for key, value in kwdata_method.items()
-        ]
-        sql_set_list_kwdata.extend(
-            [
-                f'`{key}` = :{key}'
-                for key in kwdata_replace
-            ]
-        )
-
-        # Generate SQL.
-        data_flatten = kwdata_replace
-        if where_fields is None:
-            no_where = True
-        else:
-            no_where = False
-            if where_fields.__class__ == str:
-                where_fields = [where_fields]
-        sqls_list = []
-        sql_update = f'UPDATE `{database}`.`{table}`'
-        for index, row in enumerate(data):
-            sql_parts = [sql_update]
-            for key, value in row.items():
-                if key in ('order', 'limit'):
-                    continue
-                index_key = f'{index}_{key}'
-                data_flatten[index_key] = value
-            if no_where:
-                for key in row:
-                    where_fields = [key]
-                    break
-
-            ## Part 'SET' syntax.
-            sql_set_list = sql_set_list_kwdata.copy()
-            sql_set_list.extend(
-                [
-                    f'`{key}` = :{index}_{key}'
-                    for key in row
-                    if (
-                        key not in where_fields
-                        and key not in kwdata
-                        and key not in ('order', 'limit')
-                    )
-                ]
-            )
-            sql_set = 'SET ' + ',\n    '.join(sql_set_list)
-            sql_parts.append(sql_set)
-
-            ## Part 'WHERE' syntax.
-            sql_where_list = []
-            for field in where_fields:
-                index_field = f'{index}_{field}'
-                index_value = data_flatten[index_field]
-                if index_value.__class__ in (list, tuple):
-                    sql_where_part = f'`{field}` IN :{index_field}'
-                else:
-                    sql_where_part = f'`{field}` = :{index_field}'
-                sql_where_list.append(sql_where_part)
-            sql_where = 'WHERE ' + '\n    AND '.join(sql_where_list)
-            sql_parts.append(sql_where)
-
-            ## Part 'ORDER BY' syntax.
-            order = row.get('order')
-            if order is not None:
-                sql_order = f'ORDER BY {order}'
-                sql_parts.append(sql_order)
-
-            ## Part 'LIMIT' syntax.
-            limit = row.get('limit')
-            if limit is not None:
-                sql_limit = f'LIMIT {limit}'
-                sql_parts.append(sql_limit)
-
-            ## Join sql part.
-            sql = '\n'.join(sql_parts)
-            sqls_list.append(sql)
-
-        ## Join sqls.
-        sqls = ';\n'.join(sqls_list)
-
-        # Execute SQL.
-        result = self.execute(sqls, data_flatten, report)
-
-        return result
-
-
-    def execute_delete(
-        self,
-        path: Union[str, tuple[str, str]],
-        where: Optional[str] = None,
-        order: Optional[str] = None,
-        limit: Optional[Union[int, str]] = None,
-        report: Optional[bool] = None,
-        **kwdata: Any
-    ) -> RResult:
-        """
-        Delete the data of table in the datebase.
-
-        Parameters
-        ----------
-        path : Table name, can contain database name, otherwise use `self.database`.
-            - `str`: Automatic extract database name and table name.
-            - `tuple[str, str]`: Database name and table name.
-        where : Clause `WHERE` content, join as `WHERE str`.
-        order : Clause `ORDER BY` content, join as `ORDER BY str`.
-        limit : Clause `LIMIT` content, join as `LIMIT int/str`.
-        report : Whether report SQL execute information.
-            - `None`, Use attribute `report_execute_info`: of object `ROption`.
-            - `int`: Use this value.
-        kwdata : Keyword parameters for filling.
-
-        Returns
-        -------
-        Result object.
-
-        Examples
-        --------
-        Parameter `where` and `kwdata`.
-        >>> where = '`id` IN :ids'
-        >>> ids = (1, 2)
-        >>> result = RDatabase.execute_delete('database.table', where, ids=ids)
-        >>> print(result.rowcount)
-        2
-        """
-
-        # Handle parameter.
-        if path.__class__ == str:
-            database, table, _ = self.extract_path(path)
-        else:
-            database, table = path
-
-        # Get parameter by priority.
-        database = get_first_notnull(database, self.database, default='exception')
-
-        # Generate SQL.
-        sqls = []
-
-        ## Part 'DELETE' syntax.
-        sql_delete = f'DELETE FROM `{database}`.`{table}`'
-        sqls.append(sql_delete)
-
-        ## Part 'WHERE' syntax.
-        if where is not None:
-            sql_where = f'WHERE {where}'
-            sqls.append(sql_where)
-
-        ## Part 'ORDER BY' syntax.
-        if order is not None:
-            sql_order = f'ORDER BY {order}'
-            sqls.append(sql_order)
-
-        ## Part 'LIMIT' syntax.
-        if limit is not None:
-            sql_limit = f'LIMIT {limit}'
-            sqls.append(sql_limit)
-
-        ## Join sqls.
-        sqls = '\n'.join(sqls)
-
-        # Execute SQL.
-        result = self.execute(sqls, report=report, **kwdata)
-
-        return result
-
-
-    def execute_copy(
-        self,
-        path: Union[str, tuple[str, str]],
-        where: Optional[str] = None,
-        limit: Optional[Union[int, str, tuple[int, int]]] = None,
-        report: Optional[bool] = None,
-        **kwdata: Any
-    ) -> RResult:
-        """
-        Copy record of table in the datebase.
-
-        Parameters
-        ----------
-        path : Table name, can contain database name, otherwise use `self.database`.
-            - `str`: Automatic extract database name and table name.
-            - `tuple[str, str]`: Database name and table name.
-        where : Clause `WHERE` content, join as `WHERE str`.
-        limit : Clause `LIMIT` content.
-            - `Union[int, str]`: Join as `LIMIT int/str`.
-            - `tuple[int, int]`: Join as `LIMIT int, int`.
-        report : Whether report SQL execute information.
-            - `None`, Use attribute `report_execute_info`: of object `ROption`.
-            - `int`: Use this value.
-        kwdata : Keyword parameters for filling.
-            - `In 'WHERE' syntax`: Fill 'WHERE' syntax.
-            - `Not in 'WHERE' syntax`: Fill 'INSERT' and 'SELECT' syntax.
-                `str and first character is ':'`: Use this syntax.
-                `Any`: Use this value.
-
-        Returns
-        -------
-        Result object.
-
-        Examples
-        --------
-        Parameter `where` and `kwdata`.
-        >>> where = '`id` IN :ids'
-        >>> ids = (1, 2, 3)
-        >>> result = RDatabase.execute_copy('database.table', where, 2, ids=ids, id=None, time=':NOW()')
-        >>> print(result.rowcount)
-        2
-        """
-
-        # Handle parameter.
-        if path.__class__ == str:
-            database, table, _ = self.extract_path(path)
-        else:
-            database, table = path
-
-        # Get parameter by priority.
-        database = get_first_notnull(database, self.database, default='exception')
-
-        # Get parameter.
-        table_info: list[dict] = self.info(database)(table)()
-        fields = [
-            row['COLUMN_NAME']
-            for row in table_info
-        ]
-        pattern = '(?<!\\\\):(\\w+)'
-        if where.__class__ == str:
-            where_keys = findall(pattern, where)
-        else:
-            where_keys = ()
-
-        # Generate SQL.
-        sqls = []
-
-        ## Part 'INSERT' syntax.
-        sql_fields = ', '.join(
-            f'`{field}`'
-            for field in fields
-            if field not in kwdata
-        )
-        if kwdata != {}:
-            sql_fields_kwdata = ', '.join(
-                f'`{field}`'
-                for field in kwdata
-                if field not in where_keys
-            )
-            sql_fields_filter = filter(
-                lambda sql: sql != '',
-                (
-                    sql_fields,
-                    sql_fields_kwdata
-                )
-            )
-            sql_fields = ', '.join(sql_fields_filter)
-        sql_insert = f'INSERT INTO `{database}`.`{table}`({sql_fields})'
-        sqls.append(sql_insert)
-
-        ## Part 'SELECT' syntax.
-        sql_values = ', '.join(
-            f'`{field}`'
-            for field in fields
-            if field not in kwdata
-        )
-        if kwdata != {}:
-            sql_values_kwdata = ', '.join(
-                value[1:]
-                if (
-                    value.__class__ == str
-                    and value.startswith(':')
-                    and value != ':'
-                )
-                else f':{field}'
-                for field, value in kwdata.items()
-                if field not in where_keys
-            )
-            sql_values_filter = filter(
-                lambda sql: sql != '',
-                (
-                    sql_values,
-                    sql_values_kwdata
-                )
-            )
-            sql_values = ', '.join(sql_values_filter)
-        sql_select = (
-            f'SELECT {sql_values}\n'
-            f'FROM `{database}`.`{table}`'
-        )
-        sqls.append(sql_select)
-
-        ## Part 'WHERE' syntax.
-        if where is not None:
-            sql_where = f'WHERE {where}'
-            sqls.append(sql_where)
-
-        ## Part 'LIMIT' syntax.
-        if limit is not None:
-            if limit.__class__ in (str, int):
-                sql_limit = f'LIMIT {limit}'
-            else:
-                if len(limit) == 2:
-                    sql_limit = f'LIMIT {limit[0]}, {limit[1]}'
-                else:
-                    throw(ValueError, limit)
-            sqls.append(sql_limit)
-
-        ## Join.
-        sql = '\n'.join(sqls)
-
-        # Execute SQL.
-        result = self.execute(sql, report=report, **kwdata)
-
-        return result
-
-
-    def execute_exist(
-        self,
-        path: Union[str, tuple[str, str]],
-        where: Optional[str] = None,
-        report: Optional[bool] = None,
-        **kwdata: Any
-    ) -> bool:
-        """
-        Judge the exist of record.
-
-        Parameters
-        ----------
-        path : Table name, can contain database name, otherwise use `self.database`.
-            - `str`: Automatic extract database name and table name.
-            - `tuple[str, str]`: Database name and table name.
-        where : Match condition, `WHERE` clause content, join as `WHERE str`.
-            - `None`: Match all.
-            - `str`: Match condition.
-        report : Whether report SQL execute information.
-            - `None`, Use attribute `report_execute_info`: of object `ROption`.
-            - `int`: Use this value.
-        kwdata : Keyword parameters for filling.
-
-        Returns
-        -------
-        Judged result.
-
-        Examples
-        --------
-        Parameter `where` and `kwdata`.
-        >>> data = [{'id': 1}]
-        >>> RDatabase.execute_insert('database.table', data)
-        >>> where = '`id` = :id_'
-        >>> id_ = 1
-        >>> result = RDatabase.execute_exist('database.table', where, id_=id_)
-        >>> print(result)
-        True
-        """
-
-        # Handle parameter.
-        if path.__class__ == str:
-            database, table, _ = self.extract_path(path)
-        else:
-            database, table = path
-
-        # Execute.
-        result = self.execute_select((database, table), '1', where=where, limit=1, report=report, **kwdata)
-
-        # Judge.
-        judge = result.exist
-
-        return judge
-
-
-    def execute_count(
-        self,
-        path: Union[str, tuple[str, str]],
-        where: Optional[str] = None,
-        report: Optional[bool] = None,
-        **kwdata: Any
-    ) -> int:
-        """
-        Count records.
-
-        Parameters
-        ----------
-        path : Table name, can contain database name, otherwise use `self.database`.
-            - `str`: Automatic extract database name and table name.
-            - `tuple[str, str]`: Database name and table name.
-        where : Match condition, `WHERE` clause content, join as `WHERE str`.
-            - `None`: Match all.
-            - `str`: Match condition.
-        report : Whether report SQL execute information.
-            - `None`, Use attribute `report_execute_info`: of object `ROption`.
-            - `int`: Use this value.
-        kwdata : Keyword parameters for filling.
-
-        Returns
-        -------
-        Record count.
-
-        Examples
-        --------
-        Parameter `where` and `kwdata`.
-        >>> where = '`id` IN :ids'
-        >>> ids = (1, 2)
-        >>> result = RDatabase.execute_count('database.table', where, ids=ids)
-        >>> print(result)
-        2
-        """
-
-        # Handle parameter.
-        if path.__class__ == str:
-            database, table, _ = self.extract_path(path)
-        else:
-            database, table = path
-
-        # Execute.
-        result = self.execute_select((database, table), '1', where=where, report=report, **kwdata)
-        count = result.rowcount
-
-        return count
-
-
-    def execute_generator(
-        self,
-        sql: Union[str, TextClause],
-        data: Table,
-        report: Optional[bool] = None,
-        **kwdata: Any
-    ) -> Generator[RResult, Any, None]:
-        """
-        Return a generator that can execute SQL.
-
-        Parameters
-        ----------
-        sql : SQL in method `sqlalchemy.text` format, or `TextClause` object.
-        data : Data set for filling.
-        report : Whether report SQL execute information.
-            - `None`: Use attribute `default_report`.
-            - `bool`: Use this value.
-        kwdata : Keyword parameters for filling.
-
-        Returns
-        -------
-        Generator.
-        """
-
-        # Handle parameter.
-        match data:
-            case dict():
-                data = [data]
-            case CursorResult():
-                data = to_table(data)
-            case DataFrame():
-                data = to_table(data)
-            case _:
-                data = data.copy()
-
-        # Instance.
-        rgenerator = RGenerator(
-            self.execute,
-            sql=sql,
-            report=report,
-            **kwdata
-        )
-
-        # Add.
-        for row in data:
-            rgenerator(**row)
-
-        return rgenerator.generator
-
-
-    def connect(self) -> RDBConnection:
-        """
-        Build `database connection` attributes.
-
-        Returns
-        -------
-        Database connection instance.
-        """
-
-        # Build.
-        rdbconnection = RDBConnection(
-            self.engine.connect(),
-            self
-        )
-
-        return rdbconnection
-
-
-    @property
-    def exe(self):
-        """
-        Build `database execute` attributes.
-
-        Returns
-        -------
-        Database execute instance.
-
-        Examples
-        --------
-        Execute.
-        >>> sql = 'select :value'
-        >>> result = RDBExecute(sql, value=1)
-
-        Select.
-        >>> field = ['id', 'value']
-        >>> where = '`id` = ids'
-        >>> ids = (1, 2)
-        >>> result = RDBExecute.database.table(field, where, ids=ids)
-
-        Insert.
-        >>> data = [{'id': 1}, {'id': 2}]
-        >>> duplicate = 'ignore'
-        >>> result = RDBExecute.database.table + data
-        >>> result = RDBExecute.database.table + (data, duplicate)
-        >>> result = RDBExecute.database.table + {'data': data, 'duplicate': duplicate}
-
-        Update.
-        >>> data = [{'name': 'a', 'id': 1}, {'name': 'b', 'id': 2}]
-        >>> where_fields = 'id'
-        >>> result = RDBExecute.database.table & data
-        >>> result = RDBExecute.database.table & (data, where_fields)
-        >>> result = RDBExecute.database.table & {'data': data, 'where_fields': where_fields}
-
-        Delete.
-        >>> where = '`id` IN (1, 2)'
-        >>> report = True
-        >>> result = RDBExecute.database.table - where
-        >>> result = RDBExecute.database.table - (where, report)
-        >>> result = RDBExecute.database.table - {'where': where, 'report': report}
-
-        Copy.
-        >>> where = '`id` IN (1, 2)'
-        >>> limit = 1
-        >>> result = RDBExecute.database.table * where
-        >>> result = RDBExecute.database.table * (where, limit)
-        >>> result = RDBExecute.database.table * {'where': where, 'limit': limit}
-
-        Exist.
-        >>> where = '`id` IN (1, 2)'
-        >>> report = True
-        >>> result = where in RDBExecute.database.table
-        >>> result = (where, report) in RDBExecute.database.table
-        >>> result = {'where': where, 'report': report} in RDBExecute.database.table
-
-        Count.
-        >>> result = len(RDBExecute.database.table)
-
-        Default database.
-        >>> field = ['id', 'value']
-        >>> engine = RDatabase(**server, database)
-        >>> result = engine.exe.table()
-        """
-
-        # Import.
-        from .rexecute import RDBExecute
-
-        # Build.
-        rdbexecute = RDBExecute(self)
-
-        return rdbexecute
-
-
-    @property
-    def schema(self) -> dict[str, dict[str, list]]:
-        """
-        Get schemata of databases and tables and columns.
-
-        Returns
-        -------
-        Schemata of databases and tables and columns.
-        """
-
-        # Select.
-        filter_db = (
-            'information_schema',
-            'mysql',
-            'performance_schema',
-            'sys'
-        )
-        result = self.execute_select(
-            'information_schema.COLUMNS',
-            ['TABLE_SCHEMA', 'TABLE_NAME', 'COLUMN_NAME'],
-            '`TABLE_SCHEMA` NOT IN :filter_db',
-            order='`TABLE_SCHEMA`, `TABLE_NAME`, `ORDINAL_POSITION`',
-            filter_db=filter_db
-        )
-
-        # Convert.
-        database_dict = {}
-        for database, table, column in result:
-
-            ## Index database.
-            if database not in database_dict:
-                database_dict[database] = {table: [column]}
-                continue
-            table_dict: dict = database_dict[database]
-
-            ## Index table. 
-            if table not in table_dict:
-                table_dict[table] = [column]
-                continue
-            column_list: list = table_dict[table]
-
-            ## Add column.
-            column_list.append(column)
-
-        return database_dict
-
-
-    @property
-    def info(self):
-        """
-        Build `database schema information` attributes.
-
-        Returns
-        -------
-        Database schema information instance.
-
-        Examples
-        --------
-        Get databases information of server.
-        >>> databases_info = RDBISchema()
-
-        Get tables information of database.
-        >>> tables_info = RDBISchema.database()
-
-        Get columns information of table.
-        >>> columns_info = RDBISchema.database.table()
-
-        Get database attribute.
-        >>> database_attr = RDBISchema.database['attribute']
-
-        Get table attribute.
-        >>> database_attr = RDBISchema.database.table['attribute']
-
-        Get column attribute.
-        >>> database_attr = RDBISchema.database.table.column['attribute']
-        """
-
-        # Import.
-        from .rinformation import RDBISchema
-
-        # Build.
-        rdbischema = RDBISchema(self)
-
-        return rdbischema
-
-
-    @property
-    def build(self):
-        """
-        Build `database build` attributes.
-
-        Returns
-        -------
-        Database build instance.
-        """
-
-        # Import.
-        from .rbuild import RDBBuild
-
-        # Build.
-        rdbbuild = RDBBuild(self)
-
-        return rdbbuild
-
-
-    @property
-    def file(self):
-        """
-        Build `database file` attributes.
-
-        Returns
-        -------
-        Database file instance.
-        """
-
-        # Import.
-        from .rfile import RDBFile
-
-        # Build.
-        rdbfile = RDBFile(self)
-
-        return rdbfile
-
-
-    @property
-    def status(self):
-        """
-        Build `database status parameters` attributes.
-
-        Returns
-        -------
-        Database status parameters instance.
-        """
-
-        # Import.
-        from .rparameter import RDBPStatus
-
-        # Build.
-        rdbpstatus = RDBPStatus(self, False)
-
-        return rdbpstatus
-
-
-    @property
-    def global_status(self):
-        """
-        Build global `database status parameters` instance.
-
-        Returns
-        -------
-        Global database status parameters instance.
-        """
-
-        # Import.
-        from .rparameter import RDBPStatus
-
-        # Build.
-        rdbpstatus = RDBPStatus(self, True)
-
-        return rdbpstatus
-
-
-    @property
-    def variables(self):
-        """
-        Build `database variable parameters` attributes.
-
-        Returns
-        -------
-        Database variable parameters instance.
-        """
-
-        # Import.
-        from .rparameter import RDBPVariable
-
-        # Build.
-        rdbpvariable = RDBPVariable(self, False)
-
-        return rdbpvariable
-
-
-    @property
-    def global_variables(self):
-        """
-        Build global `database variable parameters` instance.
-
-        Returns
-        -------
-        Global database variable parameters instance.
-        """
-
-        # Import.
-        from .rparameter import RDBPVariable
-
-        # Build.
-        rdbpvariable = RDBPVariable(self, True)
-
-        return rdbpvariable
-
-
-    @overload
-    def __call__(
-        self,
-        sql: Union[str, TextClause],
-        data: Optional[Table] = None,
-        report: Optional[bool] = None,
-        generator: Literal[False] = False,
-        **kwdata: Any
-    ) -> RResult: ...
-
-    @overload
-    def __call__(
-        self,
-        sql: Union[str, TextClause],
-        data: Table = None,
-        report: Optional[bool] = None,
-        generator: Literal[True] = False,
-        **kwdata: Any
-    ) -> Generator[RResult, Any, None]: ...
-
-    @overload
-    def __call__(
-        self,
-        sql: Union[str, TextClause],
-        data: None = None,
-        report: Optional[bool] = None,
-        generator: Literal[True] = False,
-        **kwdata: Any
-    ) -> NoReturn: ...
-
-    def __call__(
-        self,
-        sql: Union[str, TextClause],
-        data: Optional[Table] = None,
-        report: Optional[bool] = None,
-        generator: bool = False,
-        **kwdata: Any
-    ) -> Union[RResult, Generator[RResult, Any, None]]:
-        """
-        Execute SQL or return a generator that can execute SQL.
-
-        Parameters
-        ----------
-        sql : SQL in method `sqlalchemy.text` format, or `TextClause` object.
-        data : Data set for filling.
-        report : Whether report SQL execute information.
-            - `None`: Use attribute `default_report`.
-            - `bool`: Use this value.
-        generator : whether return a generator that can execute SQL, otherwise execute SQL.
-        kwdata : Keyword parameters for filling.
-
-        Returns
-        -------
-        Result object or generator.
-        """
-
-        # Get parameter.
-        if generator:
-            func = self.execute_generator
-        else:
-            func = self.execute
-
-        # Execute.
-        result = func(
-            sql,
-            data,
-            report,
-            **kwdata
-        )
-
-        return result
-
-
-    def __str__(self) -> str:
-        """
-        Return connection information text.
-        """
-
-        # Get parameter.
-        if hasattr(self, 'engine'):
-            attr_dict = self.__dict__
-        else:
-            rdatabase: RDatabase = self.rdatabase
-            attr_dict = {
-                **self.__dict__,
-                **rdatabase.__dict__
-            }
-
-        # Generate.
-        filter_key = (
-            'engine',
-            'connection',
-            'rdatabase',
-            'begin'
-        )
-        info = {
-            key: value
-            for key, value in attr_dict.items()
-            if key not in filter_key
-        }
-        info['count'] = self.count
-        text = join_data_text(info)
-
-        return text
-
-
-class RDBConnection(RDatabase):
-    """
-    Rey's `database connection` type.
-    """
-
-
-    def __init__(
-        self,
-        connection: Connection,
-        rdatabase: RDatabase
-    ) -> None:
-        """
-        Build `database connection` attributes.
-
-        Parameters
-        ----------
-        connection : Connection object.
-        rdatabase : RDatabase object.
-        """
-
-        # Set parameter.
-        self.connection = connection
-        self.rdatabase = rdatabase
-        self.begin = None
-        self.begin_count = 0
-        self.drivername = rdatabase.drivername
-        self.username = rdatabase.username
-        self.password = rdatabase.password
-        self.host = rdatabase.host
-        self.port = rdatabase.port
-        self.database = rdatabase.database
-        self.query = rdatabase.query
-        self.pool_recycle = rdatabase.pool_recycle
-        self.retry = rdatabase.retry
-
-
-    @override
-    def executor(
-        self,
-        connection: Connection,
-        sql: TextClause,
-        data: list[dict],
-        report: bool
-    ) -> RResult:
-        """
-        SQL executor.
-
-        Parameters
-        ----------
-        connection : Connection object.
-        sql : TextClause object.
-        data : Data set for filling.
-        report : Whether report SQL execute information.
-
-        Returns
-        -------
-        Result object.
-        """
-
-        # Create Transaction object.
-        if self.begin_count == 0:
-            self.rollback()
-            self.begin = connection.begin()
-
-        # Execute.
-
-        ## Report.
-        if report:
-            result, report_runtime = wrap_runtime(connection.execute, sql, data, _return_report=True)
-            report_info = (
-                f'{report_runtime}\n'
-                f'Row Count: {result.rowcount}'
-            )
-            sqls = [
-                sql_part.strip()
-                for sql_part in sql.text.split(';')
-            ]
-            if data == []:
-                echo(report_info, *sqls, title='SQL')
-            else:
-                echo(report_info, *sqls, data, title='SQL')
-
-        ## Not report.
-        else:
-            result = connection.execute(sql, data)
-
-        # Count.
-        syntaxes = self.get_syntax(sql)
-        if objs_in(syntaxes, 'INSERT', 'UPDATE', 'DELETE'):
-            self.begin_count += 1
-
-        return result
-
-
-    @override
-    def execute(
-        self,
-        sql: Union[str, TextClause],
-        data: Optional[Table] = None,
-        report: Optional[bool] = None,
-        **kwdata: Any
-    ) -> RResult:
-        """
-        Execute SQL.
-
-        Parameters
-        ----------
-        sql : SQL in method `sqlalchemy.text` format, or `TextClause` object.
-        data : Data set for filling.
-        report : Whether report SQL execute information.
-            - `None`: Use attribute `default_report`.
-            - `bool`: Use this value.
-        kwdata : Keyword parameters for filling.
-
-        Returns
-        -------
-        Result object.
-        """
-
-        # Get parameter by priority.
-        report = get_first_notnull(report, self.default_report, default='exception')
-
-        # Handle parameter.
-        if sql.__class__ == str:
-            sql = text(sql)
-        if data is None:
-            if kwdata == {}:
-                data = []
-            else:
-                data = [kwdata]
-        else:
-            match data:
-                case dict():
-                    data = [data]
-                case CursorResult():
-                    data = to_table(data)
-                case DataFrame():
-                    data = to_table(data)
-                case _:
-                    data = data.copy()
-            for param in data:
-                param.update(kwdata)
-
-        # Handle data.
-        data = self.handle_data(data, sql)
-
-        # Execute.
-
-        ## Can retry.
-        if (
-            self.retry
-            and self.begin_count == 0
-            and not self.is_multi_sql(sql)
-        ):
-            result = wrap_retry(
-                self.executor,
-                self.connection,
-                sql,
-                data,
-                report,
-                _report='Database Execute Operational Error',
-                _exception=OperationalError
-            )
-
-        ## Cannot retry.
-        else:
-            result = self.executor(self.connection, sql, data, report)
-
-        return result
-
-
-    def commit(self) -> None:
-        """
-        Commit cumulative executions.
-        """
-
-        # Commit.
-        if self.begin is not None:
-            self.begin.commit()
-            self.begin = None
-            self.begin_count = 0
-
-
-    def rollback(self) -> None:
-        """
-        Rollback cumulative executions.
-        """
-
-        # Rollback.
-        if self.begin is not None:
-            self.begin.rollback()
-            self.begin = None
-            self.begin_count = 0
-
-
-    def close(self) -> None:
-        """
-        Close database connection.
-        """
-
-        # Close.
-        self.connection.close()
-
-
-    def __enter__(self) -> Self:
-        """
-        Enter syntax `with`.
-
-        Returns
-        -------
-        Self.
-        """
-
-        return self
-
-
-    def __exit__(
-        self,
-        exc_type: Optional[type[BaseException]],
-        exc_instance: Optional[BaseException],
-        exc_traceback: Optional[TracebackType]
-    ) -> None:
-        """
-        Exit syntax `with`.
-
-        Parameters
-        ----------
-        exc_type : Exception type.
-        exc_instance : Exception instance.
-        exc_traceback : Exception traceback instance.
-        """
-
-        # Commit.
-        if exc_type is None:
-            self.commit()
-
-        # Close.
-        else:
-            self.close()
-
-
-    __del__ = close