python通过sqlalchemy转换为sql：如何加快导出到MS sql的速度？

我有一个约155000行和12列的数据帧。 如果我使用dataframe.to_csv将其导出为csv，则输出是一个11MB的文件（立即生成）

但是，如果我使用to_SQL方法导出到Microsoft SQL Server，则需要5到6分钟！ 没有列是文本：只有int、float、bool和dates。我见过ODBC驱动程序设置nvarchar（max）的情况，这会减慢数据传输，但这里不可能是这种情况

有没有关于如何加快出口进程的建议？导出11Mbs数据需要6分钟，这使得ODBC连接实际上无法使用

谢谢

我的代码是：

import pandas as pd
from sqlalchemy import create_engine, MetaData, Table, select
ServerName = "myserver"
Database = "mydatabase"
TableName = "mytable"

engine = create_engine('mssql+pyodbc://' + ServerName + '/' + Database)
conn = engine.connect()

metadata = MetaData(conn)

my_data_frame.to_sql(TableName,engine)

该方法向ODBC连接器生成insert语句，然后ODBC连接器将其视为常规插入

如果进展缓慢，那不是熊猫的错

将方法的输出保存到文件中，然后通过ODBC连接器重放该文件将花费相同的时间

将数据批量导入数据库的正确方法是生成一个csv文件，然后使用load命令，在SQL数据库的MS风格中，该命令称为

例如：

BULK INSERT mydatabase.myschema.mytable
FROM 'mydatadump.csv';

语法参考如下：

BULK INSERT 
   [ database_name . [ schema_name ] . | schema_name . ] [ table_name | view_name ] 
      FROM 'data_file' 
     [ WITH 
    ( 
   [ [ , ] BATCHSIZE = batch_size ] 
   [ [ , ] CHECK_CONSTRAINTS ] 
   [ [ , ] CODEPAGE = { 'ACP' | 'OEM' | 'RAW' | 'code_page' } ] 
   [ [ , ] DATAFILETYPE = 
      { 'char' | 'native'| 'widechar' | 'widenative' } ] 
   [ [ , ] FIELDTERMINATOR = 'field_terminator' ] 
   [ [ , ] FIRSTROW = first_row ] 
   [ [ , ] FIRE_TRIGGERS ] 
   [ [ , ] FORMATFILE = 'format_file_path' ] 
   [ [ , ] KEEPIDENTITY ] 
   [ [ , ] KEEPNULLS ] 
   [ [ , ] KILOBYTES_PER_BATCH = kilobytes_per_batch ] 
   [ [ , ] LASTROW = last_row ] 
   [ [ , ] MAXERRORS = max_errors ] 
   [ [ , ] ORDER ( { column [ ASC | DESC ] } [ ,...n ] ) ] 
   [ [ , ] ROWS_PER_BATCH = rows_per_batch ] 
   [ [ , ] ROWTERMINATOR = 'row_terminator' ] 
   [ [ , ] TABLOCK ] 
   [ [ , ] ERRORFILE = 'file_name' ] 
    )] 

您可以使用which，因为它使用本机DB import命令。它支持MS SQL、Postgres和MYSQL

uri_psql = 'postgresql+psycopg2://usr:pwd@localhost/db'
d6tstack.utils.pd_to_psql(df, uri_psql, 'table')
uri_mssql = 'mssql+pymssql://usr:pwd@localhost/db'
d6tstack.utils.pd_to_mssql(df, uri_mssql, 'table', 'schema') # experimental

对于导入多个CSV（带有数据架构更改）和/或在写入db之前使用pandas进行预处理也很有用，请参阅中的进一步内容

基于这个答案-

您可以使用copy_from方法模拟带有游标对象的批量加载。 这是在Postgres上测试的，请使用您的DB进行尝试：

import pandas as pd
from sqlalchemy import create_engine, MetaData, Table, select
from StringIO import StringIO

ServerName = "myserver"
Database = "mydatabase"
TableName = "mytable"

engine = create_engine('mssql+pyodbc://' + ServerName + '/' + Database) #don't forget to add a password if needed

my_data_frame.head(0).to_sql(TableName, engine, if_exists='replace', index=False)  # create an empty table - just for structure
conn = engine.raw_connection()
cur = conn.cursor()
output = StringIO()
my_data_frame.to_csv(output, sep='\t', header=False, index=False) # a CSV that will be used for the bulk load
output.seek(0)
cur.copy_from(output, TableName, null="")  # null values become ''
conn.commit()
conn.close()
cur.close()

---

如果这对任何人都有帮助，我的解决方案如下。据我所知，pandas-tosql方法一次加载一条记录

您可以创建一个大容量insert语句，加载1000行并提交该事务，而不是每次提交一行。这大大提高了速度

import pandas as pd
from sqlalchemy import create_engine
import pymssql
import os

connect_string  = [your connection string]
engine = create_engine(connect_string,echo=False)
connection = engine.raw_connection()
cursor = connection.cursor()

def load_data(report_name):
    # my report_name variable is also my sql server table name so I use that variable to create table name string
    sql_table_name = 'AR_'+str(report_name)
    global chunk # to QC chunks that fail for some reason
    for chunk in pd.read_csv(report_full_path_new,chunksize=1000):
        chunk.replace('\'','\'\'',inplace=True,regex=True) #replace single quotes in data with double single quotes to escape it in mysql
        chunk.fillna('NULL',inplace=True)

        my_data = str(chunk.to_records(index=False).tolist()) # convert data to string 
        my_data = my_data[1:-1] # clean up the ends
        my_data = my_data.replace('\"','\'').replace('\'NULL\'','NULL') #convert blanks to NULLS for mysql
        sql_table_name = [your sql server table name]

        sql = """
        INSERT INTO {0} 
        VALUES {1}

         """.format(sql_table_name,my_data)

        cursor.execute(sql)
        # you must call commit() to persist your data if you don't set autocommit to True
        connection.commit()

---

我最近也遇到了同样的问题，我想为其他人补充一个答案。

to_sql

似乎会为每一行发送一个

INSERT

查询，这使得查询速度非常慢。但是由于

0.24.0

在

pandas.to\u sql（）

中有一个

method

参数，您可以在其中定义自己的插入函数，或者只使用

method='multi'

告诉pandas在一个插入查询中传递多行，这会使它更快

请注意，数据库可能有参数限制。在这种情况下，还必须定义chunksize

因此，解决方案应该如下所示：

my_data\u frame.to_sql（TableName，engine，chunksize=，method='multi'）

---

如果您不知道数据库参数的限制，只需在不使用chunksize参数的情况下尝试。它将运行或给您一个错误，告诉您您的限制。

您可以使用它：使它更快的是pandas

to_sql

的

方法

参数。我希望这有帮助

在我的经验中，结果是从无限时间到8秒

df = pd.read_csv('test.csv')

conn = create_engine(<connection_string>)

start_time = time.time()
df.to_sql('table_name', conn, method='multi',index=False, if_exists='replace')
print("--- %s seconds ---" % (time.time() - start_time))

df=pd.read\u csv（'test.csv'））
conn=创建引擎（）
开始时间=time.time（）
df.to_sql（'table_name'，conn，method='multi'，index=False，如果_exists='replace'）
打印（“--%s秒--”%（time.time（）-start\u time））

我的时间和内存不足（从120MB CSV加载的数据帧分配的内存超过18GB），这行代码：

df.to_sql('my_table', engine, if_exists='replace', method='multi', dtype={"text_field": db.String(64), "text_field2": db.String(128), "intfield1": db.Integer(), "intfield2": db.Integer(), "floatfield": db.Float()})

下面是帮助我同时导入和跟踪插入进度的代码：

import sqlalchemy as db
engine = db.create_engine('mysql://user:password@localhost:3306/database_name', echo=False)
connection = engine.connect()
metadata = db.MetaData()

my_table = db.Table('my_table', metadata,
              db.Column('text_field', db.String(64), index=True),
              db.Column('text_field2', db.String(128), index=True),
              db.Column('intfield1', db.Integer()),
              db.Column('intfield2', db.Integer()),
              db.Column('floatfield', db.Float())
             )
metadata.create_all(engine)
kw_dict = df.reset_index().sort_values(by="intfield2", ascending=False).to_dict(orient="records")

batch_size=10000
for batch_start in range(0, len(kw_dict), batch_size):
    print("Inserting {}-{}".format(batch_start, batch_start + batch_size))
    connection.execute(my_table.insert(), kw_dict[batch_start:batch_start + batch_size])

为什么

pandas.DataFrame.to_sql

速度慢？ 将数据从

pandas

上载到Microsoft SQL Server时，实际上大部分时间都花在将

pandas

转换为Python对象，转换为MS SQL ODBC驱动程序所需的表示形式上。与基本Python代码相比，

pandas

的分析速度要快得多的原因之一是，它可以在整数/浮点数的精简本机数组上工作，这些数组的开销与它们各自的Python对应数组不同。

to_sql

方法实际上是将所有这些精简列转换为许多单独的Python对象，因此没有像其他

pandas

操作那样得到通常的性能处理

使用

turbodbc.Cursor.insertmanycolumns

加速此过程 给定一个

pandas.DataFrame

，您可以使用

turbodbc

和

pyarrow

插入数据，与转换为Python对象相比，转换开销更小

import pyarrow as pa
import turbodbc

cursor = …  # cursor to a MS SQL connection initiated with turbodbc
df = …  # the pd.DataFrame to be inserted

# Convert the pandas.DataFrame to a pyarrow.Table, most of the columns
# will be zero-copy and thus this is quite fast.
table = pa.Table.from_pandas(table)

# Insert into the database
cursor.executemanycolumns("INSERT INTO my_table VALUES (?, ?, ?)",
                           table)

为什么这样更快？ 我们不是转换

pd.DataFrame

->Python对象集合->ODBC数据结构，而是转换路径

pd.DataFrame

->

pyarrow.Table

->ODBC结构。这是因为：

• pandas.DataFrame

  的大多数列可以转换为

  pyarrow.Table

  的列，而无需复制。表的列将引用相同的内存。因此没有进行实际的转换
• 转换完全在具有本机类型的本机代码中完成。这意味着只要没有

  object

  类型化列，就不会出现Python对象的开销

---

正如在其他答案中所说的，减速和/或超时的原因是熊猫反复插入许多单行。大量insert命令速度较慢，并且/或者可能导致目标数据库过载

使用method='multi'告诉pandas分块上传。这要快得多，不会那么容易超时

sqlEngine=create_engine('mysql+mysqlconnector://'+config['user']+':'+config['pass']+'@'+config['host']+'/'+config['dbname'])
dbConnection=sqlEngine.connect()
df.to_sql('table_name',con=dbConnection,method='multi',if_exists='append',index=False)
dbConnection.close()

---

我唯一能想到的就是将结构（即列名和数据类型，但不包括行）导出到SQL，然后将文件导出到CSV，并使用类似导入/导出向导的方法将CSV文件附加到SQL表中。这样我就不必再次定义所有的列类型；这一点很重要，因为导入工具倾向于读取前x行以猜测数据类型

sqlEngine=create_engine('mysql+mysqlconnector://'+config['user']+':'+config['pass']+'@'+config['host']+'/'+config['dbname'])
dbConnection=sqlEngine.connect()
df.to_sql('table_name',con=dbConnection,method='multi',if_exists='append',index=False)
dbConnection.close()