python - 来自 postgres 的非规范化 numpy 数组

Question

以下查询提取了 ca。 100'000 个数据点到 python。数据将使用 matplotlib 绘制。

cur.execute("""SELECT  \
        loggingdb_ips_integer.ipsvalue,
        loggingdb_ips_integer.ipstimestamp,
        loggingdb_ips_integer.varid 
        FROM public.loggingdb_ips_integer
        WHERE
        (loggingdb_ips_integer.varid = 17884) OR
        (loggingdb_ips_integer.varid = 55437) OR
        (loggingdb_ips_integer.varid = 34637) OR
        (loggingdb_ips_integer.varid = 17333)
        ; """)

使用每个 WHERE 子句分别运行 4 个查询是否更有效，还是我应该一次拉入整个辣酱 Jade 米饼馅并将其转换为具有 3 个轴的 numpy 数组？如果后者更有效，那么转换(规范化？)数组的最佳方法是什么？请不要因为我的天真而指责我——我是一名训练有素的医生；我对编码的理解非常有限!

Answer 1

Python 与数据库之间的通信相对较慢。所以通常你想减少查询的数量。尽可能多地在数据库内部执行数据库工作，并仅提取您需要的数据。

这些一般经验法则让我猜测使用 1 个查询会比使用 4 个查询更好。但是，100K 行并不是很多，因此使用哪种方法都无关紧要。除非你要运行这个代码数百万次并且需要尽可能地减少每一纳秒，否则你很容易浪费更多的时间来烦恼这个而不是选择一个节省的时间。如果你真的需要那种性能，那么你应该重新考虑 Python 是否是适合这项工作的语言。俗话说，preoptimization is the root of all evil .

但由于这很可能不是您代码的主要瓶颈，所以我会根据最容易阅读和维护的代码来选择使用哪种方法，而不一定是最快的。

如果每个 varid 有完全相同的行数然后你可以使用 NumPy reshape 技巧将数据哄骗成 3 个轴，第一个轴对应于变量(见下文)。在这种情况下，进行一次查询可能是最简单也是最快的。

如果行数不完全一样，那么代码就变得有点复杂了。您需要一个 Python 循环和一个 bool NumPy 掩码来选择正确的行。在这种情况下，只进行四个单独的查询可能会更容易。

---

现在，出于好奇，我决定测试我的说法，即 1 个查询比 4 个查询快。也许您会在这里找到一些可以重复使用的代码。

import oursql
import config
import numpy as np

def create_random_data():
    connection = oursql.connect(
        host=config.HOST, user=config.USER, passwd=config.PASS,
        db='test')
    with connection.cursor() as cursor:
        sql = 'DROP TABLE IF EXISTS `mytable`'
        cursor.execute(sql)
        sql = '''CREATE TABLE `mytable` (
            `id` INT(11) NOT NULL AUTO_INCREMENT,
            `ipsvalue` INT(11) DEFAULT NULL,
            `ipstimestamp` INT(11) DEFAULT NULL,
            `varid` INT(11) DEFAULT NULL,        
            PRIMARY KEY (`id`)
            ) ENGINE=MyISAM DEFAULT CHARSET=latin1'''
        cursor.execute(sql)
        sql = '''
            INSERT INTO mytable (ipsvalue, ipstimestamp, varid)
            VALUES (?, ?, ?)'''
        N = 10**5
        args = np.empty((N, 3))
        args[:, :-1] = np.random.randint(100, size=(N, 2))
        args[:, -1] = np.tile(np.array([17884, 55437, 34637, 17333]), N//4)
        cursor.executemany(sql, args)

def one_query():
    connection = oursql.connect(
        host=config.HOST, user=config.USER, passwd=config.PASS,
        db='test')
    with connection.cursor() as cursor:
        varids = sorted((17884, 55437, 34637, 17333))
        sql = '''SELECT varid, ipsvalue, ipstimestamp FROM mytable
                 WHERE varid IN {}
                 ORDER BY varid, ipstimestamp, ipsvalue'''.format(tuple(varids))
        cursor.execute(sql)
        data = np.array(cursor.fetchall())
        data = data.reshape(4, -1, 3)
        arr = dict()
        for i, varid in enumerate(varids): 
            arr[varid] = data[i]
        return arr

def four_queries():
    connection = oursql.connect(
        host=config.HOST, user=config.USER, passwd=config.PASS,
        db='test')
    with connection.cursor() as cursor:
        arr = dict()
        varids = (17884, 55437, 34637, 17333)
        for varid in varids:
            sql = '''SELECT varid, ipsvalue, ipstimestamp FROM mytable
                     WHERE varid = ?
                     ORDER BY ipstimestamp, ipsvalue'''
            cursor.execute(sql, [varid])
            arr[varid] = np.array(cursor.fetchall())
        return arr

arr = one_query()
arr2 = four_queries()
assert all([np.all(arr[key]==arr2[key]) for key in arr])

---

one_query 和four_queries 都返回一个字典，其键是varid 值。如您所见，性能并没有什么不同，尽管使用一个查询比四个查询快一点:

In [219]: %timeit four_queries()
1 loops, best of 3: 238 ms per loop

In [221]: %timeit one_query()
1 loops, best of 3: 195 ms per loop