Question

这两个命令之间的执行时间是否存在差异：

import pandas as pd

df=pd.read_sql_query('SELECT * FROM TABLE',conn)
df=pd.read_sql_table(TABLE, conn)

感谢您的帮助

Answer 1

我认为你不会注意到这种差异。

以下是两个函数的源代码：

In [398]: pd.read_sql_query??
Signature: pd.read_sql_query(sql, con, index_col=None, coerce_float=True, params=None, parse_dates=None, chunksize=None)
Source:
def read_sql_query(sql, con, index_col=None, coerce_float=True, params=None,
                   parse_dates=None, chunksize=None):
    pandas_sql = pandasSQL_builder(con)
    return pandas_sql.read_query(
        sql, index_col=index_col, params=params, coerce_float=coerce_float,
        parse_dates=parse_dates, chunksize=chunksize)

和

In [399]: pd.read_sql_table??
Signature: pd.read_sql_table(table_name, con, schema=None, index_col=None, coerce_float=True, parse_dates=None, columns=None, chunksize=None
)
Source:
def read_sql_table(table_name, con, schema=None, index_col=None,
                   coerce_float=True, parse_dates=None, columns=None,
                   chunksize=None):
    con = _engine_builder(con)
    if not _is_sqlalchemy_connectable(con):
        raise NotImplementedError("read_sql_table only supported for "
                                  "SQLAlchemy connectable.")
    import sqlalchemy
    from sqlalchemy.schema import MetaData
    meta = MetaData(con, schema=schema)
    try:
        meta.reflect(only=[table_name], views=True)
    except sqlalchemy.exc.InvalidRequestError:
        raise ValueError("Table %s not found" % table_name)

    pandas_sql = SQLDatabase(con, meta=meta)
    table = pandas_sql.read_table(
        table_name, index_col=index_col, coerce_float=coerce_float,
        parse_dates=parse_dates, columns=columns, chunksize=chunksize)

    if table is not None:
        return table
    else:
        raise ValueError("Table %s not found" % table_name, con)

注意：我无意中切断了文档字符串......

Answer 2

我尝试了无数次，尽管我读了上面的内容，但我不同意大部分过程或结论。

过程

如果您要比较两种方法，添加厚层 SQLAlchemy 或 pandasSQL_builder（即 pandas.io.sql.pandasSQL_builder，没有 import）和其他类似非独立 片段至少可以说没有帮助。在没有噪音的情况下比较两种方法的唯一方法是尽可能干净地使用它们，至少在类似的情况下使用它们。

假设

有一种关于假设的说法......在假设差异不明显和提出关于 pd.read_sql_query 的无用考虑之间，这一点变得严重模糊。这里唯一明显的考虑是，如果有人比较pd.read_sql_query 和pd.read_sql_table，那就是桌子，整张桌子，只有桌子。调用 where、join 和其他只是浪费时间。

此外，该问题明确询问了 read_sql_table 和 read_sql_query 之间的区别，并带有 SELECT * FROM table。

我的代码

我在 SQLite、MariaDB 和 PostgreSQL 上一遍又一遍地运行这个。我专门使用 SQLAlchemy 来创建引擎，因为 pandas 需要这样做。数据来自 coffee-quality-database，我将文件 data/arabica_data_cleaned.csv 在所有三个引擎中预加载到名为 arabica

的数据库中名为 coffee 的表

这是我的脚本的总结版本：

import time
import pandas as pd
from sqlalchemy import create_engine

sqlite_engine = create_engine('sqlite:///coffee.db', echo=False)
mariadb_engine = create_engine('mariadb+mariadbconnector://root:admin@127.0.0.1:3306/coffee')
postgres_engine = create_engine('postgresql://postgres:admin@127.0.0.1:5432/coffee')

for engine in [sqlite_engine, mariadb_engine, postgres_engine]:
    print(engine)
    print('\tpd.read_sql_query:')
    startTime = time.time()
    for i in range(100):
        pd.read_sql_query('SELECT * FROM arabica;', engine)
    print(f"\t[-- TIME --] {time.time()-startTime:.2f} sec\n")
    print('\tpd.read_sql_table:')
    startTime = time.time()
    for i in range(100):
        pd.read_sql_table('arabica', engine)
    print(f"\t[-- TIME --] {time.time()-startTime:.2f} sec\n")

版本是：

Python：3.9.0
熊猫：1.2.4
SQLAlchemy：1.4.13
时间：内置

我的结果

这是一个示例输出：

Engine(sqlite:///coffee.db)
        pd.read_sql_query:
        [-- TIME --] 2.58 sec

        pd.read_sql_table:
        [-- TIME --] 3.60 sec

Engine(mariadb+mariadbconnector://root:***@127.0.0.1:3306/coffee)
        pd.read_sql_query:
        [-- TIME --] 2.84 sec

        pd.read_sql_table:
        [-- TIME --] 4.15 sec

Engine(postgresql://postgres:***@127.0.0.1:5432/coffee)
        pd.read_sql_query:
        [-- TIME --] 2.18 sec

        pd.read_sql_table:
        [-- TIME --] 4.01 sec

结论

以上是一个示例输出，但我一遍又一遍地运行，唯一的观察结果是在每次运行中，pd.read_sql_table 总是 strong> 需要比 pd.read_sql_query 更长的时间。这听起来很违反直觉，但这就是我们在向此处倾注知识之前实际隔离问题并测试的原因。

我没有机会对结果进行适当的统计分析，但乍一看，我可能会说差异很大，因为“列”（query 和 {{1 }} 时间）在近距离范围内返回（从运行到运行）并且都相当远。在某些运行中，table 需要两倍于某些引擎的时间。

如果/当我有机会进行这样的分析时，我会用结果和 table 证据补充这个答案。

上下文

我最初的想法是在表达到数千列时调查 SQL 与 MongoDB 的适用性。 matplotlib（来自 pdmongo 包）破坏了 pdmongo.read_mongo——它对大型表的表现非常差——但达不到 pd.read_sql_table。

在大约 900 列的情况下，pd.read_sql_query 的性能比 pd.read_sql_query 高 5 到 10 倍！

Answer 3

主要区别很明显，
与
df=pd.read_sql_query('SELECT * FROM TABLE',conn)
您使用的 sql 查询可能很复杂，因此执行会消耗大量时间/资源。

与
df=pd.read_sql_table(TABLE, conn)
您下载一个表并仅指定列、架构等。

Answer 4

在 read_sql_query 中，您可以添加 where 子句，可以添加连接等，这样可以减少从数据库移动到数据框中的数据量。如果您有一张大表并且只需要少量行，那就更好了。

另一方面，如果您的表很小，请使用 read_sql_table 并在 python 中操作数据框。它比 SQL 更灵活。

pandas读取sql查询和读取sql表之间的区别

4 个答案:

过程

假设

我的代码

我的结果

结论

上下文