使用带有 psycopg2 的二进制 COPY 表 FROM

Posted 2023-02-24

【中文标题】使用带有 psycopg2 的二进制 COPY 表 FROM

【英文标题】：Use binary COPY table FROM with psycopg2

【发布时间】：2011-12-29 22:46:58

【问题描述】：

我有数千万行要从多维数组文件传输到 PostgreSQL 数据库。我的工具是 Python 和 psycopg2。批量插入数据的最有效方法是使用copy_from。但是，我的数据大多是 32 位浮点数（real 或 float4），所以我宁愿不从 real → text → real 转换。这是一个示例数据库 DDL：

CREATE TABLE num_data
(
  id serial PRIMARY KEY NOT NULL,
  node integer NOT NULL,
  ts smallint NOT NULL,
  val1 real,
  val2 double precision
);

这是我使用 Python 使用字符串（文本）的地方：

# Just one row of data
num_row = [23253, 342, -15.336734, 2494627.949375]

import psycopg2
# Python3:
from io import StringIO
# Python2, use: from cStringIO import StringIO

conn = psycopg2.connect("dbname=mydb user=postgres")
curs = conn.cursor()

# Convert floating point numbers to text, write to COPY input
cpy = StringIO()
cpy.write('\t'.join([repr(x) for x in num_row]) + '\n')

# Insert data; database converts text back to floating point numbers
cpy.seek(0)
curs.copy_from(cpy, 'num_data', columns=('node', 'ts', 'val1', 'val2'))
conn.commit()

是否有可以使用二进制模式工作的等价物？即，将浮点数保持为二进制？这不仅可以保持浮点精度，而且可以更快。

（注意：要查看与示例相同的精度，请使用SET extra_float_digits='2'）

【问题讨论】：

好吧，你可以import binary files with COPY，但为此，整个文件必须采用特定的二进制格式，而不仅仅是一个值。

@Erwin，是的，我了解了 COPY 的二进制模式，但我只是不确定 psycopg2 是否支持它，或者我是否应该使用不同的方法。

我使用的二进制文件格式的唯一应用是导入从 from PostgreSQL 导出的文件。我不知道任何其他可以编写特定格式的程序。但这并不意味着它不能在某个地方。如果是重复操作，可以将文本形式COPY到Postgres一次，把二进制文件写出来，下次再写COPY FROM .. FORMAT BINARY。

【参考方案1】：

这是 Python 3 的 COPY FROM 的二进制等效项：

from io import BytesIO
from struct import pack
import psycopg2

# Two rows of data; "id" is not in the upstream data source
# Columns: node, ts, val1, val2
data = [(23253, 342, -15.336734, 2494627.949375),
        (23256, 348, 43.23524, 2494827.949375)]

conn = psycopg2.connect("dbname=mydb user=postgres")
curs = conn.cursor()

# Determine starting value for sequence
curs.execute("SELECT nextval('num_data_id_seq')")
id_seq = curs.fetchone()[0]

# Make a binary file object for COPY FROM
cpy = BytesIO()
# 11-byte signature, no flags, no header extension
cpy.write(pack('!11sii', b'PGCOPY\n\377\r\n\0', 0, 0))

# Columns: id, node, ts, val1, val2
# Zip: (column position, format, size)
row_format = list(zip(range(-1, 4),
                      ('i', 'i', 'h', 'f', 'd'),
                      ( 4,   4,   2,   4,   8 )))
for row in data:
    # Number of columns/fields (always 5)
    cpy.write(pack('!h', 5))
    for col, fmt, size in row_format:
        value = (id_seq if col == -1 else row[col])
        cpy.write(pack('!i' + fmt, size, value))
    id_seq += 1  # manually increment sequence outside of database

# File trailer
cpy.write(pack('!h', -1))

# Copy data to database
cpy.seek(0)
curs.copy_expert("COPY num_data FROM STDIN WITH BINARY", cpy)

# Update sequence on database
curs.execute("SELECT setval('num_data_id_seq', %s, false)", (id_seq,))
conn.commit()

---

更新

我重写了上述编写 COPY 文件的方法。我在 Python 中的数据位于 NumPy 数组中，因此使用这些是有意义的。下面是一个例子data 有 1M 行，7 列：

import psycopg2
import numpy as np
from struct import pack
from io import BytesIO
from datetime import datetime

conn = psycopg2.connect("dbname=mydb user=postgres")
curs = conn.cursor()

# NumPy record array
shape = (7, 2000, 500)
print('Generating data with %i rows, %i columns' % (shape[1]*shape[2], shape[0]))

dtype = ([('id', 'i4'), ('node', 'i4'), ('ts', 'i2')] +
         [('s' + str(x), 'f4') for x in range(shape[0])])
data = np.empty(shape[1]*shape[2], dtype)
data['id'] = np.arange(shape[1]*shape[2]) + 1
data['node'] = np.tile(np.arange(shape[1]) + 1, shape[2])
data['ts'] = np.repeat(np.arange(shape[2]) + 1, shape[1])
data['s0'] = np.random.rand(shape[1]*shape[2]) * 100
prv = 's0'
for nxt in data.dtype.names[4:]:
    data[nxt] = data[prv] + np.random.rand(shape[1]*shape[2]) * 10
    prv = nxt

在我的数据库中，我有两个看起来像这样的表：

CREATE TABLE num_data_binary
(
  id integer PRIMARY KEY,
  node integer NOT NULL,
  ts smallint NOT NULL,
  s0 real,
  s1 real,
  s2 real,
  s3 real,
  s4 real,
  s5 real,
  s6 real
) WITH (OIDS=FALSE);

还有另一个名为num_data_text的类似表。

这里有一些简单的辅助函数，通过使用 NumPy 记录数组中的信息为 COPY（文本和二进制格式）准备数据：

def prepare_text(dat):
    cpy = BytesIO()
    for row in dat:
        cpy.write('\t'.join([repr(x) for x in row]) + '\n')
    return(cpy)

def prepare_binary(dat):
    pgcopy_dtype = [('num_fields','>i2')]
    for field, dtype in dat.dtype.descr:
        pgcopy_dtype += [(field + '_length', '>i4'),
                         (field, dtype.replace('<', '>'))]
    pgcopy = np.empty(dat.shape, pgcopy_dtype)
    pgcopy['num_fields'] = len(dat.dtype)
    for i in range(len(dat.dtype)):
        field = dat.dtype.names[i]
        pgcopy[field + '_length'] = dat.dtype[i].alignment
        pgcopy[field] = dat[field]
    cpy = BytesIO()
    cpy.write(pack('!11sii', b'PGCOPY\n\377\r\n\0', 0, 0))
    cpy.write(pgcopy.tostring())  # all rows
    cpy.write(pack('!h', -1))  # file trailer
    return(cpy)

这就是我使用辅助函数对两种 COPY 格式方法进行基准测试的方式：

def time_pgcopy(dat, table, binary):
    print('Processing copy object for ' + table)
    tstart = datetime.now()
    if binary:
        cpy = prepare_binary(dat)
    else:  # text
        cpy = prepare_text(dat)
    tendw = datetime.now()
    print('Copy object prepared in ' + str(tendw - tstart) + '; ' +
          str(cpy.tell()) + ' bytes; transfering to database')
    cpy.seek(0)
    if binary:
        curs.copy_expert('COPY ' + table + ' FROM STDIN WITH BINARY', cpy)
    else:  # text
        curs.copy_from(cpy, table)
    conn.commit()
    tend = datetime.now()
    print('Database copy time: ' + str(tend - tendw))
    print('        Total time: ' + str(tend - tstart))
    return

time_pgcopy(data, 'num_data_text', binary=False)
time_pgcopy(data, 'num_data_binary', binary=True)

这是最后两个time_pgcopy 命令的输出：

Processing copy object for num_data_text
Copy object prepared in 0:01:15.288695; 84355016 bytes; transfering to database
Database copy time: 0:00:37.929166
        Total time: 0:01:53.217861
Processing copy object for num_data_binary
Copy object prepared in 0:00:01.296143; 80000021 bytes; transfering to database
Database copy time: 0:00:23.325952
        Total time: 0:00:24.622095

因此，使用二进制方法，NumPy → 文件和文件 → 数据库步骤都更快。明显的区别在于 Python 如何准备 COPY 文件，这对于文本来说真的很慢。一般来说，二进制格式作为该模式的文本格式在 2/3 的时间内加载到数据库中。

最后，我比较了数据库中两个表中的值，看看数字是否不同。大约 1.46% 的行对列 s0 具有不同的值，而对于 s6，这一比例增加到 6.17%（可能与我使用的随机方法有关）。所有 70M 32 位浮点值之间的非零绝对差值介于 9.3132257e-010 和 7.6293945e-006 之间。文本和二进制加载方法之间的这些微小差异是由于文本格式方法所需的浮点→文本→浮点转换的精度损失。

【讨论】：

很酷。你是不是自己写的从某个地方得到它？它真的能提高性能吗？

如果它有效，太棒了！除了格式，解决方案是使用 psycopg 的copy_expert()。

@Erwin，是的，我使用 copy、struct 和 dtype 的优秀文档对其进行了编程。基准已经出现，并且看起来不错。

我围绕这个为 ruby​​ 创建了一个 gem。支持大多数数据类型。 github.com/pbrumm/pg_data_encoder

Here 是我的版本。基于迈克的版本。它非常特别，但有两个优点： - 期望生成器并通过重载 readline 充当流 - 示例如何以 hstore 二进制格式写入。