数据库

DatabaseReader #

基类: BaseReader

简单的数据库读取器。

通过查询从数据库读取数据并返回LlamaIndex Document对象。允许指定元数据列（可选择重命名）并从文本内容中排除列。还可以从行数据生成自定义的Document ID。

当与 sql_database 一起传递时，不支持 schema 参数。

如果 sql_database 对象是使用 schema 创建的，则将使用该 schema。

参数

名称	类型	描述	默认值
`sql_database`	`Optional[SQLDatabase]`	要使用的SQL数据库，包括要指定的表名。更多详情请参阅 :ref:`Ref-Struct-Store`。	`无`
`engine`	`Optional[Engine]`	数据库连接的SQLAlchemy Engine对象。	`无`
`uri`	`Optional[str]`	数据库连接的uri。	`无`
`scheme`	`Optional[str]`	数据库连接的scheme。	`无`
`host`	`Optional[str]`	数据库连接的host。	`无`
`port`	`Optional[int]`	数据库连接的port。	`无`
`user`	`Optional[str]`	数据库连接的user。	`无`
`password`	`Optional[str]`	数据库连接的password。	`无`
`dbname`	`Optional[str]`	数据库连接的dbname。	`无`

返回值

名称	类型	描述
`DatabaseReader`		一个DatabaseReader对象。

注意

schema (Optional[str]): 数据库schema 仅在此类内部创建连接对象时（即传递 engine、uri 或单独的连接参数时）才会生效。如果您提供一个已构建的 SQLDatabase 对象，则使用其内部 schema（如果存在），并且此参数将被忽略。

连接模式#

+----------------------------+-----------+---------------------------------------+ | 模式 | 支持 | 注意 | +============================+===========+=======================================+ | sql_database | ✖ | 如果在此处需要处理 schema，请传递一个预配置的 SQLDatabase 对象。 | | | | | +----------------------------+-----------+---------------------------------------+ | engine + schema | ✔ | | +----------------------------+-----------+---------------------------------------+ | uri + schema | ✔ | | +----------------------------+-----------+---------------------------------------+ | scheme/host/… + | ✔ | | | schema | | | +----------------------------+-----------+---------------------------------------+

(schema = 数据库命名空间; scheme = 驱动/方言，例如 postgresql+psycopg)

源代码位于 llama-index-integrations/readers/llama-index-readers-database/llama_index/readers/database/base.py

class DatabaseReader(BaseReader):
    """
    Simple Database reader.

    Reads data from a database via a query and returns LlamaIndex Documents.
    Allows specifying columns for metadata (with optional renaming) and
    excluding columns from text content. Can also generate custom Document IDs
    from row data.

    Note: The `schema` parameter is not supported when passed with `sql_database`.
        If the `sql_database` object was created with a schema, it will be used.

    Args:
        sql_database (Optional[SQLDatabase]): SQL database to use,
            including table names to specify.
            See :ref:`Ref-Struct-Store` for more details.

        OR

        engine (Optional[Engine]): SQLAlchemy Engine object of the database connection.

        OR

        uri (Optional[str]): uri of the database connection.

        OR

        scheme (Optional[str]): scheme of the database connection.
        host (Optional[str]): host of the database connection.
        port (Optional[int]): port of the database connection.
        user (Optional[str]): user of the database connection.
        password (Optional[str]): password of the database connection.
        dbname (Optional[str]): dbname of the database connection.

    Returns:
        DatabaseReader: A DatabaseReader object.

    Note:
        schema (Optional[str]):
            Database schema **only honored when a connection object is created
            inside this class** (i.e. when you pass `engine`, `uri`, or individual
            connection parameters).
            If you supply an already-built `SQLDatabase`, its internal schema (if
            any) is used and this argument is ignored.

    Connection patterns
    -------------------
    +----------------------------+-----------+---------------------------------------+
    | Pattern                    | Supports  | Notes                                 |
    +============================+===========+=======================================+
    | ``sql_database``           | ✖         | Pass a pre-configured ``SQLDatabase`` |
    |                            |           | if you need schema handling here.     |
    +----------------------------+-----------+---------------------------------------+
    | ``engine`` + ``schema``    | ✔         |                                       |
    +----------------------------+-----------+---------------------------------------+
    | ``uri`` + ``schema``       | ✔         |                                       |
    +----------------------------+-----------+---------------------------------------+
    | ``scheme/host/…`` +        | ✔         |                                       |
    | ``schema``                 |           |                                       |
    +----------------------------+-----------+---------------------------------------+

    (*schema* = database namespace; *scheme* = driver/dialect, e.g. ``postgresql+psycopg``)

    """

    def __init__(
        self,
        sql_database: Optional[SQLDatabase] = None,
        engine: Optional[Engine] = None,
        uri: Optional[str] = None,
        scheme: Optional[str] = None,
        host: Optional[str] = None,
        port: Optional[str] = None,
        user: Optional[str] = None,
        password: Optional[str] = None,
        dbname: Optional[str] = None,
        schema: Optional[str] = None,
        *args: Any,
        **kwargs: Any,
    ) -> None:
        """Initialize with parameters."""
        db_kwargs = kwargs.copy()
        if schema and not sql_database:
            db_kwargs["schema"] = schema
            self.schema = schema if schema else db_kwargs.get("schema", None)
        else:
            self.schema = None

        if sql_database:
            self.sql_database = sql_database
        elif engine:
            self.sql_database = SQLDatabase(engine, *args, **db_kwargs)
        elif uri:
            self.uri = uri
            self.sql_database = SQLDatabase.from_uri(uri, *args, **db_kwargs)
        elif scheme and host and port and user and password and dbname:
            uri = f"{scheme}://{user}:{password}@{host}:{port}/{dbname}"
            self.uri = uri
            self.sql_database = SQLDatabase.from_uri(uri, *args, **db_kwargs)
        else:
            raise ValueError(
                "You must provide either a SQLDatabase, "
                "a SQL Alchemy Engine, a valid connection URI, or a valid "
                "set of credentials."
            )

    def lazy_load_data(
        self,
        query: str,
        metadata_cols: Optional[Iterable[Union[str, Tuple[str, str]]]] = None,
        excluded_text_cols: Optional[Iterable[str]] = None,
        document_id: Optional[Callable[[Dict[str, Any]], str]] = None,
        **load_kwargs: Any,
    ) -> Generator[Document, Any, None]:
        """
        Lazily query and load data from the Database.

        Args:
            query (str): SQL query to execute.
            metadata_cols (Optional[Iterable[Union[str, Tuple[str, str]]]]):
                Iterable of column names or (db_col, meta_key) tuples to include
                in Document metadata. If str, the column name is used as key.
                If tuple, uses first element as DB column and second as metadata key.
                If two entries map to the same metadata key, the latter will silently
                overwrite the former - **avoid duplicates**.
            excluded_text_cols (Optional[Iterable[str]]): Iterable of column names to be
                excluded from Document text. Useful for metadata-only columns.
            document_id (Optional[Callable[[Dict[str, Any]], str]]): A function
                that takes a row (as a dict) and returns a string to be used as the
                Document's `id_`, this replaces the deprecated `doc_id` field.
                **MUST** return a string, falling back to auto-generated UUID.
            **load_kwargs: Additional keyword arguments (ignored).

        Yields:
            Document: A Document object for each row fetched.

        Usage Pattern for Metadata-Only Columns:
            To include `my_col` ONLY in metadata (not text), specify it in
            `metadata_cols=['my_col']` and `excluded_text_cols=['my_col']`.

        Usage Pattern for Renaming Metadata Keys:
            To include DB column `db_col_name` in metadata with the key `meta_key_name`,
            use `metadata_cols=[('db_col_name', 'meta_key_name')]`.

        """
        exclude_set: Set[str] = set(excluded_text_cols or [])
        missing_columns: Set[str] = set()
        invalid_columns: Set[str] = set()

        with self.sql_database.engine.connect() as connection:
            if not query:
                raise ValueError("A query parameter is necessary.")

            result = connection.execute(text(query))
            column_names = list(result.keys())

            for row in result:
                row_values: Dict[str, Any] = dict(zip(column_names, row))
                doc_metadata: Dict[str, Any] = {}

                # Process metadata_cols based on Union type
                if metadata_cols:
                    for item in metadata_cols:
                        db_col: str
                        meta_key: str
                        if isinstance(item, str):
                            db_col = item
                            meta_key = item
                        elif (
                            isinstance(item, tuple)
                            and len(item) == 2
                            and all(isinstance(s, str) for s in item)
                        ):
                            db_col, meta_key = item
                        elif f"{item!r}" not in invalid_columns:
                            invalid_columns.add(f"{item!r}")
                            logger.warning(
                                f"Skipping invalid item in metadata_cols: {item!r}"
                            )
                            continue
                        else:
                            continue

                        if db_col in row_values:
                            doc_metadata[meta_key] = row_values[db_col]
                        elif db_col not in row_values and db_col not in missing_columns:
                            missing_columns.add(db_col)
                            logger.warning(
                                f"Column '{db_col}' specified in metadata_cols not found in query result."
                            )

                # Prepare text content
                text_parts: List[str] = [
                    f"{col}: {val}"
                    for col, val in row_values.items()
                    if col not in exclude_set
                ]
                text_resource = MediaResource(text=", ".join(text_parts))
                params = {
                    "text_resource": text_resource,
                    "metadata": doc_metadata,
                }

                if document_id:
                    try:
                        # Ensure function receives the row data
                        id_: Optional[str] = document_id(row_values)
                        if not isinstance(id_, str):
                            logger.warning(
                                f"document_id did not return a string for row {row_values}. Got: {type(id_)}"
                            )
                        if id_ is not None:
                            params["id_"] = id_
                    except Exception as e:
                        logger.warning(
                            f"document_id failed for row {row_values}: {e}",
                            exc_info=True,
                        )

                yield Document(**params)

    def load_data(
        self,
        query: str,
        metadata_cols: Optional[Iterable[Union[str, Tuple[str, str]]]] = None,
        excluded_text_cols: Optional[Iterable[str]] = None,
        document_id: Optional[Callable[[Dict[str, Any]], str]] = None,
        **load_kwargs: Any,
    ) -> List[Document]:
        """
        Query and load data from the Database into a list of Documents.

        Args:
            query (str): SQL query to execute.
            metadata_cols (Optional[Iterable[Union[str, Tuple[str, str]]]]):
                Iterable of column names or (db_col, meta_key) tuples to include
                in Document metadata. If str, the column name is used as key.
                If tuple, uses first element as DB column and second as metadata key.
                If two entries map to the same metadata key, the latter will silently
                overwrite the former - **avoid duplicates**.
            excluded_text_cols (Optional[Iterable[str]]): Iterable of column names to be
                excluded from Document text. Useful for metadata-only columns.
            document_id (Optional[Callable[[Dict[str, Any]], str]]): A function
                that takes a row (as a dict) and returns a string to be used as the
                Document's `id_`, this replaces the deprecated `doc_id` field.
                **MUST** return a string, falling back to auto-generated UUID.
            **load_kwargs: Additional arguments passed to lazy_load_data.

        Returns:
            List[Document]: A list of Document objects.

        """
        return list(
            self.lazy_load_data(
                query=query,
                metadata_cols=metadata_cols,
                excluded_text_cols=excluded_text_cols,
                document_id=document_id,
                **load_kwargs,
            )
        )

    async def aload_data(
        self,
        query: str,
        metadata_cols: Optional[Iterable[Union[str, Tuple[str, str]]]] = None,
        excluded_text_cols: Optional[Iterable[str]] = None,
        document_id: Optional[Callable[[Dict[str, Any]], str]] = None,
        **load_kwargs: Any,
    ) -> List[Document]:
        """
        Asynchronously query and load data from the Database into a list.

        Note: Implementation uses `asyncio.to_thread`; database I/O still
            runs in a worker thread, not an async driver.

        Args:
            query (str): SQL query to execute.
            metadata_cols (Optional[Iterable[Union[str, Tuple[str, str]]]]):
                Iterable of column names or (db_col, meta_key) tuples to include
                in Document metadata. If str, the column name is used as key.
                If tuple, uses first element as DB column and second as metadata key.
                If two entries map to the same metadata key, the latter will silently
                overwrite the former - **avoid duplicates**.
            excluded_text_cols (Optional[Iterable[str]]): Iterable of column names to be
                excluded from Document text. Useful for metadata-only columns.
            document_id (Optional[Callable[[Dict[str, Any]], str]]): A function
                that takes a row (as a dict) and returns a string to be used as the
                Document's `id_`, this replaces the deprecated `doc_id` field.
                **MUST** return a string, falling back to auto-generated UUID.
            **load_kwargs: Additional arguments passed to underlying load methods.

        Returns:
            List[Document]: A list of Document objects.

        """
        func = functools.partial(
            self.load_data,  # Target the sync load_data
            query=query,
            metadata_cols=metadata_cols,
            excluded_text_cols=excluded_text_cols,
            document_id=document_id,
            **load_kwargs,
        )
        return await asyncio.to_thread(func)

lazy_load_data #

lazy_load_data(query: str, metadata_cols: Optional[Iterable[Union[str, Tuple[str, str]]]] = None, excluded_text_cols: Optional[Iterable[str]] = None, document_id: Optional[Callable[[Dict[str, Any]], str]] = None, **load_kwargs: Any) -> Generator[Document, Any, None]

从数据库延迟查询和加载数据。

参数

名称	类型	描述	默认值
`query`	`str`	要执行的SQL查询。	必需
`metadata_cols`	`Optional[Iterable[Union[str, Tuple[str, str]]]]`	要包含在Document元数据中的列名或(db_col, meta_key)元组的迭代器。如果是str，列名用作键。如果是元组，第一个元素用作DB列名，第二个用作元数据键。如果两个条目映射到相同的元数据键，后者将静默覆盖前者 - 请避免重复。	`无`
`excluded_text_cols`	`Optional[Iterable[str]]`	要从Document文本中排除的列名的迭代器。对于仅元数据列很有用。	`无`
`document_id`	`Optional[Callable[[Dict[str, Any]], str]]`	一个函数，接受一行数据（以字典形式）并返回一个字符串作为Document的 `id_`，这取代了已弃用的 `doc_id` 字段。必须返回一个字符串，否则将回退到自动生成的UUID。	`无`
`**load_kwargs`	`Any`	额外的关键字参数（被忽略）。	`{}`

Yields

名称	类型	描述
`Document`	`Document`	为获取的每一行数据生成一个Document对象。

仅元数据列的使用模式

要将 my_col **仅**包含在元数据中（不包含在文本中），请将其指定在 metadata_cols=['my_col'] 和 excluded_text_cols=['my_col'] 中。

重命名元数据键的使用模式

要将数据库列 db_col_name 以 meta_key_name 为键包含在元数据中，请使用 metadata_cols=[('db_col_name', 'meta_key_name')]。

源代码位于 llama-index-integrations/readers/llama-index-readers-database/llama_index/readers/database/base.py

def lazy_load_data(
    self,
    query: str,
    metadata_cols: Optional[Iterable[Union[str, Tuple[str, str]]]] = None,
    excluded_text_cols: Optional[Iterable[str]] = None,
    document_id: Optional[Callable[[Dict[str, Any]], str]] = None,
    **load_kwargs: Any,
) -> Generator[Document, Any, None]:
    """
    Lazily query and load data from the Database.

    Args:
        query (str): SQL query to execute.
        metadata_cols (Optional[Iterable[Union[str, Tuple[str, str]]]]):
            Iterable of column names or (db_col, meta_key) tuples to include
            in Document metadata. If str, the column name is used as key.
            If tuple, uses first element as DB column and second as metadata key.
            If two entries map to the same metadata key, the latter will silently
            overwrite the former - **avoid duplicates**.
        excluded_text_cols (Optional[Iterable[str]]): Iterable of column names to be
            excluded from Document text. Useful for metadata-only columns.
        document_id (Optional[Callable[[Dict[str, Any]], str]]): A function
            that takes a row (as a dict) and returns a string to be used as the
            Document's `id_`, this replaces the deprecated `doc_id` field.
            **MUST** return a string, falling back to auto-generated UUID.
        **load_kwargs: Additional keyword arguments (ignored).

    Yields:
        Document: A Document object for each row fetched.

    Usage Pattern for Metadata-Only Columns:
        To include `my_col` ONLY in metadata (not text), specify it in
        `metadata_cols=['my_col']` and `excluded_text_cols=['my_col']`.

    Usage Pattern for Renaming Metadata Keys:
        To include DB column `db_col_name` in metadata with the key `meta_key_name`,
        use `metadata_cols=[('db_col_name', 'meta_key_name')]`.

    """
    exclude_set: Set[str] = set(excluded_text_cols or [])
    missing_columns: Set[str] = set()
    invalid_columns: Set[str] = set()

    with self.sql_database.engine.connect() as connection:
        if not query:
            raise ValueError("A query parameter is necessary.")

        result = connection.execute(text(query))
        column_names = list(result.keys())

        for row in result:
            row_values: Dict[str, Any] = dict(zip(column_names, row))
            doc_metadata: Dict[str, Any] = {}

            # Process metadata_cols based on Union type
            if metadata_cols:
                for item in metadata_cols:
                    db_col: str
                    meta_key: str
                    if isinstance(item, str):
                        db_col = item
                        meta_key = item
                    elif (
                        isinstance(item, tuple)
                        and len(item) == 2
                        and all(isinstance(s, str) for s in item)
                    ):
                        db_col, meta_key = item
                    elif f"{item!r}" not in invalid_columns:
                        invalid_columns.add(f"{item!r}")
                        logger.warning(
                            f"Skipping invalid item in metadata_cols: {item!r}"
                        )
                        continue
                    else:
                        continue

                    if db_col in row_values:
                        doc_metadata[meta_key] = row_values[db_col]
                    elif db_col not in row_values and db_col not in missing_columns:
                        missing_columns.add(db_col)
                        logger.warning(
                            f"Column '{db_col}' specified in metadata_cols not found in query result."
                        )

            # Prepare text content
            text_parts: List[str] = [
                f"{col}: {val}"
                for col, val in row_values.items()
                if col not in exclude_set
            ]
            text_resource = MediaResource(text=", ".join(text_parts))
            params = {
                "text_resource": text_resource,
                "metadata": doc_metadata,
            }

            if document_id:
                try:
                    # Ensure function receives the row data
                    id_: Optional[str] = document_id(row_values)
                    if not isinstance(id_, str):
                        logger.warning(
                            f"document_id did not return a string for row {row_values}. Got: {type(id_)}"
                        )
                    if id_ is not None:
                        params["id_"] = id_
                except Exception as e:
                    logger.warning(
                        f"document_id failed for row {row_values}: {e}",
                        exc_info=True,
                    )

            yield Document(**params)

load_data #

load_data(query: str, metadata_cols: Optional[Iterable[Union[str, Tuple[str, str]]]] = None, excluded_text_cols: Optional[Iterable[str]] = None, document_id: Optional[Callable[[Dict[str, Any]], str]] = None, **load_kwargs: Any) -> List[Document]

从数据库查询数据并将其加载到Document列表中。

参数

名称	类型	描述	默认值
`query`	`str`	要执行的SQL查询。	必需
`metadata_cols`	`Optional[Iterable[Union[str, Tuple[str, str]]]]`	要包含在Document元数据中的列名或(db_col, meta_key)元组的迭代器。如果是str，列名用作键。如果是元组，第一个元素用作DB列名，第二个用作元数据键。如果两个条目映射到相同的元数据键，后者将静默覆盖前者 - 请避免重复。	`无`
`excluded_text_cols`	`Optional[Iterable[str]]`	要从Document文本中排除的列名的迭代器。对于仅元数据列很有用。	`无`
`document_id`	`Optional[Callable[[Dict[str, Any]], str]]`	一个函数，接受一行数据（以字典形式）并返回一个字符串作为Document的 `id_`，这取代了已弃用的 `doc_id` 字段。必须返回一个字符串，否则将回退到自动生成的UUID。	`无`
`**load_kwargs`	`Any`	传递给 lazy_load_data 的额外参数。	`{}`

返回值

类型	描述
`List[Document]`	List[Document]: 一个Document对象列表。

源代码位于 llama-index-integrations/readers/llama-index-readers-database/llama_index/readers/database/base.py

def load_data(
    self,
    query: str,
    metadata_cols: Optional[Iterable[Union[str, Tuple[str, str]]]] = None,
    excluded_text_cols: Optional[Iterable[str]] = None,
    document_id: Optional[Callable[[Dict[str, Any]], str]] = None,
    **load_kwargs: Any,
) -> List[Document]:
    """
    Query and load data from the Database into a list of Documents.

    Args:
        query (str): SQL query to execute.
        metadata_cols (Optional[Iterable[Union[str, Tuple[str, str]]]]):
            Iterable of column names or (db_col, meta_key) tuples to include
            in Document metadata. If str, the column name is used as key.
            If tuple, uses first element as DB column and second as metadata key.
            If two entries map to the same metadata key, the latter will silently
            overwrite the former - **avoid duplicates**.
        excluded_text_cols (Optional[Iterable[str]]): Iterable of column names to be
            excluded from Document text. Useful for metadata-only columns.
        document_id (Optional[Callable[[Dict[str, Any]], str]]): A function
            that takes a row (as a dict) and returns a string to be used as the
            Document's `id_`, this replaces the deprecated `doc_id` field.
            **MUST** return a string, falling back to auto-generated UUID.
        **load_kwargs: Additional arguments passed to lazy_load_data.

    Returns:
        List[Document]: A list of Document objects.

    """
    return list(
        self.lazy_load_data(
            query=query,
            metadata_cols=metadata_cols,
            excluded_text_cols=excluded_text_cols,
            document_id=document_id,
            **load_kwargs,
        )
    )

aload_data `async` #

aload_data(query: str, metadata_cols: Optional[Iterable[Union[str, Tuple[str, str]]]] = None, excluded_text_cols: Optional[Iterable[str]] = None, document_id: Optional[Callable[[Dict[str, Any]], str]] = None, **load_kwargs: Any) -> List[Document]

异步地从数据库查询数据并加载到列表中。

实现使用了 asyncio.to_thread；数据库I/O仍然

在工作线程中运行，而不是在异步驱动中。

参数

名称	类型	描述	默认值
`query`	`str`	要执行的SQL查询。	必需
`metadata_cols`	`Optional[Iterable[Union[str, Tuple[str, str]]]]`	要包含在Document元数据中的列名或(db_col, meta_key)元组的迭代器。如果是str，列名用作键。如果是元组，第一个元素用作DB列名，第二个用作元数据键。如果两个条目映射到相同的元数据键，后者将静默覆盖前者 - 请避免重复。	`无`
`excluded_text_cols`	`Optional[Iterable[str]]`	要从Document文本中排除的列名的迭代器。对于仅元数据列很有用。	`无`
`document_id`	`Optional[Callable[[Dict[str, Any]], str]]`	一个函数，接受一行数据（以字典形式）并返回一个字符串作为Document的 `id_`，这取代了已弃用的 `doc_id` 字段。必须返回一个字符串，否则将回退到自动生成的UUID。	`无`
`**load_kwargs`	`Any`	传递给底层加载方法的额外参数。	`{}`

返回值

类型	描述
`List[Document]`	List[Document]: 一个Document对象列表。

源代码位于 llama-index-integrations/readers/llama-index-readers-database/llama_index/readers/database/base.py

async def aload_data(
    self,
    query: str,
    metadata_cols: Optional[Iterable[Union[str, Tuple[str, str]]]] = None,
    excluded_text_cols: Optional[Iterable[str]] = None,
    document_id: Optional[Callable[[Dict[str, Any]], str]] = None,
    **load_kwargs: Any,
) -> List[Document]:
    """
    Asynchronously query and load data from the Database into a list.

    Note: Implementation uses `asyncio.to_thread`; database I/O still
        runs in a worker thread, not an async driver.

    Args:
        query (str): SQL query to execute.
        metadata_cols (Optional[Iterable[Union[str, Tuple[str, str]]]]):
            Iterable of column names or (db_col, meta_key) tuples to include
            in Document metadata. If str, the column name is used as key.
            If tuple, uses first element as DB column and second as metadata key.
            If two entries map to the same metadata key, the latter will silently
            overwrite the former - **avoid duplicates**.
        excluded_text_cols (Optional[Iterable[str]]): Iterable of column names to be
            excluded from Document text. Useful for metadata-only columns.
        document_id (Optional[Callable[[Dict[str, Any]], str]]): A function
            that takes a row (as a dict) and returns a string to be used as the
            Document's `id_`, this replaces the deprecated `doc_id` field.
            **MUST** return a string, falling back to auto-generated UUID.
        **load_kwargs: Additional arguments passed to underlying load methods.

    Returns:
        List[Document]: A list of Document objects.

    """
    func = functools.partial(
        self.load_data,  # Target the sync load_data
        query=query,
        metadata_cols=metadata_cols,
        excluded_text_cols=excluded_text_cols,
        document_id=document_id,
        **load_kwargs,
    )
    return await asyncio.to_thread(func)

数据库

DatabaseReader #

连接模式#

lazy_load_data #

load_data #

aload_data async #

aload_data `async` #