Pandas: 대기 시간이 긴 연결을 통해 to_sql에서 엄청난 속도 향상을 위해 다중 행 삽입 사용

이것은 합리적으로 보입니다. 조사해 주셔서 감사합니다!

구현의 경우 sqlalchemy가 이것을 지원하지 않는 데이터베이스 특징을 어떻게 처리하는지에 따라 달라집니다(지금은 테스트할 수 없지만 sqlalchemy에서 오류가 발생하는 것 같습니다(예: http://stackoverflow.com/questions/ 23886764/multiple-insert-statements-in-mssql-with-sqlalchemy) 또한 많은 사람들이 청크 크기를 설정해야 하는 결과를 초래하는 경우 실제로 기본값으로 하는 것은 좋은 생각이 아닙니다(우리가 설정하지 않는 한 기본적으로 값으로 chunksize).
따라서 키워드를 추가하는 것이 더 나은 것 같습니다.

@artemyk @mangecoeur @hayd @danielballan

분명히 SQLAlchemy에는 dialect.supports_multivalues_insert 플래그가 있습니다(예: http://pydoc.net/Python/SQLAlchemy/0.8.3/sqlalchemy.sql.compiler/ 참조, 다른 버전에서는 supports_multirow_insert 라고 할 수 있음, https ://www.mail-archive.com/[email protected]/msg202880.html ).

이것은 삽입 속도를 많이 높일 수 있고 지원을 쉽게 확인할 수 있기 때문에 기본적으로 할 수 있고 chunksize를 기본값으로 설정할 수도 있다고 생각합니다(예: 16kb 청크... 확실하지 않음 대부분의 상황에서 너무 큼). 다중 행 삽입이 실패하면 청크 크기를 낮추도록 제안하는 예외가 발생할 수 있습니까?

이제 SQLAlchemy 사람들에게 SQL Server >2005에서 supports_multivalues_insert 를 true로 설정하도록 설득해야 합니다(코드에 해킹하여 제대로 작동하지만 기본적으로 켜져 있지 않음).

좀 더 주제별 메모에서 나는 청크 크기가 까다로울 수 있다고 생각합니다. mysql 설정(대용량 패킷을 허용하도록 구성)에서 chunksize=5000을 설정할 수 있습니다. SQLServer 설정에서는 500이 너무 컸지만 100은 제대로 작동했습니다. 그러나 이 기술의 대부분의 이점은 한 번에 1행을 100에서 1000으로 삽입하는 것이 아니라 100으로 삽입하는 데서 오는 것이 사실일 것입니다.

chunksize=None 가 "적절하게 청크 크기 선택"을 의미한다면 어떻게 될까요? 5000, 500, 50, 1과 같은 것을 시도하십시오. 사용자는 청크 크기를 지정하여 이 기능을 끌 수 있습니다. 이러한 시도의 오버헤드가 너무 크면 @maxgrenderjones 제안이 좋습니다. chunksize=10 가 chunksize=1 보다 더 나은 기본값입니다.

그 마지막 코멘트에서 " chunksize=10 는 chunksize=1 보다 더 나은 기본값입니다. " -> 그것은 완전히 사실이 아니라고 생각합니다. 현재 상황은 여러 행의 단일 행 삽입 명령문(청크 크기가 1이 아님)으로 구성된 실행 명령문을 _one_ 수행하는 것입니다. 반면 chunksize=10 는 하나의 다중 행이 있을 때마다 많은 실행 명령문을 수행함을 의미합니다. 끼워 넣다.
그리고 이것이 반드시 더 빠른지는 모르겠지만 상황에 따라 많이 다릅니다. 예를 들어 현재 코드와 로컬 sqlite 데이터베이스의 경우:

In [4]: engine = create_engine('sqlite:///:memory:') #, echo='debug')

In [5]: df = pd.DataFrame(np.random.randn(50000, 10))

In [6]: %timeit df.to_sql('test_default', engine, if_exists='replace')
1 loops, best of 3: 956 ms per loop

In [7]: %timeit df.to_sql('test_default', engine, if_exists='replace', chunksize=10)
1 loops, best of 3: 2.23 s per loop

그러나 물론 이것은 다중 행 기능을 사용하지 않습니다.

다른 사람에게 유용할 수 있는 원숭이 패치 방법을 알아냈습니다. 팬더를 가져오기 전에 이 코드가 있어야 합니다.

from pandas.io.sql import SQLTable

def _execute_insert(self, conn, keys, data_iter):
    print "Using monkey-patched _execute_insert"
    data = [dict((k, v) for k, v in zip(keys, row)) for row in data_iter]
    conn.execute(self.insert_statement().values(data))

SQLTable._execute_insert = _execute_insert

새로운 multirow=True 키워드(현재 기본값은 False임)를 통해 이 기능을 추가하는 것으로 시작할 수 있습니다. 그러면 기본적으로 활성화할 수 있는지 나중에 항상 확인할 수 있습니다.

@maxgrenderjones @nhockham 이 이것을 추가하기 위해 PR을 하고 싶습니까?

@jorisvandenbossche 특정 성능 프로필을 처리하기 위해 키워드 인수를 추가하기 시작하는 것은 위험하다고 생각합니다. 모든 경우에 더 빠르다고 보장할 수 있다면(필요한 경우 입력을 기반으로 최상의 방법을 결정하도록 하여) 플래그가 전혀 필요하지 않습니다.

서로 다른 DB 설정은 서로 다른 성능 최적화(다른 DB 성능 프로필, 로컬 대 네트워크, 대용량 메모리 대 고속 SSD 등)를 가질 수 있으며, 각각에 대해 키워드 플래그를 추가하기 시작하면 엉망이 됩니다.

성능별 구현을 해결하기 위해 SQLDatabase 및 SQLTable의 하위 클래스를 만드는 것이 좋습니다. 이러한 하위 클래스는 개체 지향 API를 통해 사용됩니다. 아마도 "백엔드 전환" 방법을 추가할 수 있지만 솔직히 OO API를 사용하는 것은 매우 간단하므로 이미 전문화된 사용 사례에 대해서는 과도합니다.

Postgres에 대용량 데이터 세트를 로드하기 위해 이러한 하위 클래스를 만들었습니다(실제로 데이터를 CSV에 저장한 다음 내장된 비표준 COPY FROM sql 명령을 사용하는 것이 삽입을 사용하는 것보다 훨씬 빠릅니다. https://gist.github 참조. com/mangecoeur/1fbd63d4758c2ba0c470#file-pandas_postgres-py). 그것을 사용하려면 PgSQLDatabase(engine, <args>).to_sql(frame, name,<kwargs>) 를 하면 됩니다.

참고로 다중 행 기능을 사용하여 @jorisvandenbossche (12월 3일 게시물)의 코드를 실행해 보았습니다. 꽤 느립니다. 따라서 여기서 속도 절충은 사소한 것이 아닙니다.

In [4]: engine = create_engine('sqlite:///:memory:') #, echo='debug')

In [5]: df = pd.DataFrame(np.random.randn(50000, 10))

In [6]: 

In [6]: %timeit df.to_sql('test_default', engine, if_exists='replace')
1 loops, best of 3: 1.05 s per loop

In [7]: 

In [7]: from pandas.io.sql import SQLTable

In [8]: 

In [8]: def _execute_insert(self, conn, keys, data_iter):
   ...:         data = [dict((k, v) for k, v in zip(keys, row)) for row in data_iter]
   ...:         conn.execute(self.insert_statement().values(data))
   ...:     

In [9]: SQLTable._execute_insert = _execute_insert

In [10]: 

In [10]: reload(pd)
Out[10]: <module 'pandas' from '/usr/local/lib/python2.7/site-packages/pandas/__init__.pyc'>

In [11]: 

In [11]: %timeit df.to_sql('test_default', engine, if_exists='replace', chunksize=10)
1 loops, best of 3: 9.9 s per loop

또한 키워드 매개변수를 추가하는 것이 위험하다는 데 동의합니다. 그러나 다중 행 기능은 매우 기본적인 것 같습니다. 또한 'monkey-patching'은 키워드 매개변수보다 API 변경에 더 강력하지 않을 수 있습니다.

내가 의심한 대로야. 원숭이 패치는 내가 제안한 솔루션이 아닙니다. 오히려 정보에 입각한 사용자가 OO 인터페이스를 통해 사용할 수 있는 여러 성능 지향 하위 클래스를 제공합니다(너무 많은 옵션이 있는 기능적 API 로드를 방지하기 위해)

------원문-----
보낸 사람: "Artemy Kolchinsky" [email protected]
보낸 날짜: ‎26/‎02/‎2015 17:13
받는 사람: "pydata/pandas" [email protected]
참조: "mangecoeur" 존. [email protected]
제목: Re: [pandas] to_sqlover 대기 시간이 긴 연결에서 엄청난 속도 향상을 위해 다중 행 삽입을 사용합니다(#8953).

참고로 다중 행 기능을 사용하여 @jorisvandenbossche (12월 3일 게시물)의 코드를 실행해 보았습니다. 꽤 느립니다. 따라서 여기서 속도 절충은 사소한 것이 아닙니다.
[4]에서: engine = create_engine('sqlite:///:memory:') #, echo='debug')

[5]에서: df = pd.DataFrame(np.random.randn(50000, 10))

[6]에서:

[6]에서: %timeit df.to_sql('test_default', 엔진, if_exists='replace')
1개 루프, 3개 중 최고: 루프당 1.05초

[7]에서:

[7]에서: pandas.io.sql에서 SQLTable 가져오기

[8]에서:

[8]에서: def _execute_insert(self, conn, keys, data_iter):
...: 데이터 = [dict((k, v) for k, v in zip(keys, row)) for row in data_iter]
...: conn.execute(self.insert_statement().values(data))
...:

[9]에서: SQLTable._execute_insert = _execute_insert

[10]에서:

[10]에서: 다시 로드(pd)
아웃[10]:

[11]에서:

[11]에서: %timeit df.to_sql('test_default', 엔진, if_exists='replace', chunksize=10)
1개 루프, 3개 중 최고: 루프당 9.9초
또한 키워드 매개변수를 추가하는 것이 위험하다는 데 동의합니다. 그러나 다중 행 기능은 매우 기본적인 것 같습니다. 또한 'monkey-patching'은 키워드 매개변수보다 API 변경에 더 강력하지 않을 수 있습니다.
—
이 이메일에 직접 회신하거나 GitHub에서 확인하세요.

초기 티켓 제목에 따라 이 접근 방식이 모든 경우에 바람직하다고 생각하지 않으므로 기본값으로 설정하지 않습니다. 그러나 그것 없이는 판다 to_sql 를 사용할 수 없으므로 계속 변경을 요청하는 것이 중요합니다. (팬더 버전을 업그레이드할 때 가장 먼저 변경하는 항목이기도 합니다.) 합리적인 chunksize 값에 관해서는, 패킷 크기가 예측하기 어려운 방식으로 얼마나 많은 열(그리고 그 안에 무엇이 들어 있는지)에 따라 달라지기 때문에 하나의 진정한 n 가 없다고 생각합니다. . 불행히도 chunksize 를 너무 높게 설정하면(아마도 SQLAlchemy의 패치를 제외하고 다중 행 삽입이 켜지지 않는 이유일 수 있음) 완전히 관련이 없어 보이는 오류 메시지와 함께 SQLServer가 실패하지만, mysql 와 잘 작동합니다. 사용자는 n 값이 허용 가능한 큰 패킷 크기(백업 데이터베이스가 무엇이든 간에)를 초래할 가능성이 있는 값을 결정하기 위해 실험해야 할 수 있습니다. 팬더가 n 를 선택하면 구현 세부 사항에서 우리가 원하는 것보다 훨씬 더 아래로 떨어질 가능성이 높습니다(즉, 최대 가능한 추상화 SQLALchemy 접근 방식과 반대 방향).

요컨대, 사용 방법에 대한 유용한 설명과 함께 키워드로 추가하는 것이 좋습니다. 키워드가 구현을 선택하는 데 사용된 것은 이번이 처음은 아니지만(http://pandas.pydata.org/pandas-docs/dev/generated/pandas.DataFrame.apply.html 참조) 아마도 그렇지 않을 것입니다. 가장 좋은 예는 설명을 읽어도 raw= 이 무엇을 의미하는지 처음에 몰랐기 때문입니다!

나는 그것이 또한 엄청난 양의 메모리를 소비한다는 것을 알아차렸습니다. 약 700,000개의 행과 301개의 열이 있는 1.6GB 이상의 DataFrame과 마찬가지로 삽입하는 동안 거의 34GB가 필요합니다! 그것은 비효율적인 것과 같습니다. 왜 그럴 수 있는지에 대한 아이디어가 있습니까? 다음은 화면 클립입니다.

안녕하세요 여러분,
이 문제에 진전이 있습니까?

to_sql을 사용하여 약 200K 행을 삽입하려고 하지만 시간이 오래 걸리고 엄청난 양의 메모리를 소비합니다! Chuncksize를 사용하면 메모리에 도움이 되지만 여전히 속도가 매우 느립니다.

내 인상은 MSSQL DBase 추적을 보면 삽입이 실제로 한 번에 한 행씩 수행된다는 것입니다.

이제 실행 가능한 유일한 접근 방식은 공유 폴더의 csv 파일에 덤프하고 BULK INSERT를 사용하는 것입니다. 그러나 그것은 매우 성가시고 부적절합니다!

@andreacassioli odo 를 사용하여 중간 CSV 파일을 통해 SQL 데이터베이스에 DataFrame 을 삽입할 수 있습니다. SQL Database에 CSV 로드를 참조하세요.

ODBC를 사용하여 BULK INSERT 성능에 근접할 수 있다고 생각하지 않습니다.

@ostrokach 감사합니다. 실제로 지금 csv 파일을 사용하고 있습니다. 내가 가까이 갈 수 있다면, 나는 단순함을 위해 약간의 시간을 교환할 것입니다!

나는 이것이 누군가를 도울 수 있다고 생각했습니다.
http://docs.sqlalchemy.org/en/latest/faq/performance.html#i -m-inserting-400-000-rows-with-the-orm-and-it-s-really-slow

@indera pandas는 ORM을 사용하지 않고 sqlalchemy Core만 사용합니다(이는 대용량 삽입에 사용하도록 제안된 문서 항목).

그동안 이 문제를 해결하는 방법에 대한 합의가 있습니까? 나는 수백만 개의 행을 postgres에 삽입하고 있으며 영원히 걸립니다. CSV / odo가 갈 길입니까?

@russlamb 이 문제를 해결하는 실용적인 방법은 단순히 일괄 업로드하는 것입니다. 이것은 누군가 db 특정이므로 odo 에는 postgresl ( mysql 일 수 있음)에 대한 솔루션이 있다고 생각합니다. sqlserver와 같은 경우 '직접 수행'해야 합니다(IOW 작성해야 함).

sqlserver의 경우 SQLAlchemy 엔터티와 함께 ​​FreeTDS 드라이버( http://www.freetds.org/software.html 및 https://github.com/mkleehammer/pyodbc )를 사용하여 매우 빠른 삽입(데이터 프레임당 20K 행)을 생성했습니다. :

from sqlalchemy.ext.declarative import declarative_base
Base = declarative_base()


class DemographicEntity(Base):
    __tablename__ = 'DEMOGRAPHIC'

    patid = db.Column("PATID", db.Text, primary_key=True)
    """
    patid = db.Column("PATID", db.Text, primary_key=True, autoincrement=False, nullable=True)
    birth_date = db.Column("BIRTH_DATE", db.Date)
    birth_time = db.Column("BIRTH_TIME", db.Text(5))
    sex = db.Column("SEX", db.Text(2))

def get_db_url(db_host, db_port, db_name, db_user, db_pass):
    params = parse.quote(
        "Driver={{FreeTDS}};Server={};Port={};"
        "Database={};UID={};PWD={};"
        .format(db_host, db_port, db_name, db_user, db_pass))
    return 'mssql+pyodbc:///?odbc_connect={}'.format(params)

def get_db_pool():
    """
    Create the database engine connection.
    <strong i="6">@see</strong> http://docs.sqlalchemy.org/en/latest/core/engines.html

    :return: Dialect object which can either be used directly
            to interact with the database, or can be passed to
            a Session object to work with the ORM.
    """
    global DB_POOL

    if DB_POOL is None:
        url = get_db_url(db_host=DB_HOST, db_port=DB_PORT, db_name=DB_NAME,
                         db_user=DB_USER, db_pass=DB_PASS)
        DB_POOL = db.create_engine(url,
                                   pool_size=10,
                                   max_overflow=5,
                                   pool_recycle=3600)

    try:
        DB_POOL.execute("USE {db}".format(db=DB_NAME))
    except db.exc.OperationalError:
        logger.error('Database {db} does not exist.'.format(db=DB_NAME))

    return DB_POOL


def save_frame():
    db_pool = get_db_pool()
    records = df.to_dict(orient='records')
    result = db_pool.execute(entity.__table__.insert(), records)

CSV / odo가 갈 길입니까?

이 솔루션은 다중 행/청크 크기 설정에 관계없이 거의 항상 더 빠를 것입니다.

그러나 @russlamb , 그러한 다중 행 키워드가 귀하의 경우에 개선이 될지 여부를 듣는 것은 항상 흥미롭습니다. 이를 쉽게 테스트하는 방법은 https://github.com/pandas-dev/pandas/issues/8953#issuecomment -76139975를 참조하세요.

(반드시 기본값을 변경하지 않고도) 이것을 지정할 수 있는 방법을 원한다는 데 동의한다고 생각합니다. 따라서 누군가가 이를 위해 PR을 하고 싶다면 그것은 확실히 환영할 일입니다.
이 기능을 추가하는 방법에 대한 약간의 토론만 있었습니다(새 키워드 대 OO API를 사용하는 하위 클래스).

@jorisvandenbossche 위에서 링크한 문서는 "또는 SQLAlchemy ORM은 소량의 ORM으로 코어 수준 INSERT 및 UPDATE 구문을 방출하기 위해 작업 단위 프로세스의 하위 섹션에 후크를 제공하는 대량 작업 방법 제품군을 제공합니다. -기반 자동화."

내가 제안하는 것은 위에 게시한 코드에서와 같이 속도 향상을 위해 내부적으로 SQLAlchemy ORM을 사용하는 to_sql 에 대한 sqlserver 특정 버전을 구현하는 것입니다.

이것은 이전에 제안되었습니다. 당신이 가는 방법은 pandas sql을 구현하는 것입니다.
백엔드에 최적화된 클래스 나는 과거에 사용 요지를 게시했습니다.
훨씬 빠른 postgres COPY FROM 명령. 그러나 비슷한 것을
이제 odo에서 사용할 수 있으며 더 강력한 방식으로 구축되었습니다. 별로 없다
odo에서 작업을 복제할 때 IMHO를 가리킵니다.

2017년 3월 7일 00시 53분에 "Andrei Sura" [email protected] 이 다음과 같이 썼습니다.

@jorisvandenbossche https://github.com/jorisvandenbossche 문서
위에서 언급한 링크는 "또는 SQLAlchemy ORM이 대량을 제공합니다.
메소드의 하위 섹션에 대한 후크를 제공하는 작업 모음
코어 레벨 INSERT 및 UPDATE를 내보내는 작업 단위 프로세스
약간의 ORM 기반 자동화로 구성됩니다."

내가 제안하는 것은 sqlserver 특정 버전을 구현하는 것입니다.
내부적으로 속도 향상을 위해 SQLAlchemy 코어를 사용하는 "to_sql".

—
당신이 언급되었기 때문에 이것을 받는 것입니다.
이 이메일에 직접 답장하고 GitHub에서 확인하세요.
https://github.com/pandas-dev/pandas/issues/8953#issuecomment-284437587 ,
또는 스레드 음소거
https://github.com/notifications/unsubscribe-auth/AAtYVDXKLuTlsh9ycpMQvU5C0hs_RxuYks5rjCwBgaJpZM4DCjLh
.

또한 sqlalchemy가 대신 핵심이 될 수 있다고 언급했습니다. 뭔가가 아니면
많이 변경되었습니다. 어떤 경우에도 sqlalchemy 코어만 사용됩니다. 만약 너라면
코어를 사용하는 것보다 속도를 더 높이려면 더 낮은 수준인 db로 이동해야 합니다.
특정 최적화

2017년 3월 7일 00시 53분에 "Andrei Sura" [email protected] 이 다음과 같이 썼습니다.

@jorisvandenbossche https://github.com/jorisvandenbossche 문서
위에서 언급한 링크는 "또는 SQLAlchemy ORM이 대량을 제공합니다.
메소드의 하위 섹션에 대한 후크를 제공하는 작업 모음
코어 레벨 INSERT 및 UPDATE를 내보내는 작업 단위 프로세스
약간의 ORM 기반 자동화로 구성됩니다."

내가 제안하는 것은 sqlserver 특정 버전을 구현하는 것입니다.
내부적으로 속도 향상을 위해 SQLAlchemy 코어를 사용하는 "to_sql".

—
당신이 언급되었기 때문에 이것을 받는 것입니다.
이 이메일에 직접 답장하고 GitHub에서 확인하세요.
https://github.com/pandas-dev/pandas/issues/8953#issuecomment-284437587 ,
또는 스레드 음소거
https://github.com/notifications/unsubscribe-auth/AAtYVDXKLuTlsh9ycpMQvU5C0hs_RxuYks5rjCwBgaJpZM4DCjLh
.

이 문제가 해결/해결되고 있습니까? 현재 pandas 데이터 프레임을 SQL db에 삽입하는 것은 장난감 데이터 프레임이 아닌 한 매우 느립니다. 해결 방법을 결정하고 추진해 볼까요?

@dfernan 위에서 언급했듯이 odo 를 보고 싶을 수도 있습니다. 중간 CSV 파일을 사용하면 여기에서 어떤 종류의 개선이 발생하더라도 sqlalchemy를 거치는 것보다 항상 훨씬 더 빠릅니다...

@ostrokach , odo의 동작이 일반적인 Pandas 사용자가 원하는 것인지 확신할 수 없습니다. ODBC를 통한 다중 행 삽입은 아마도 대부분의 분석가에게 충분히 빠를 것입니다.

나 자신을 대변하기 위해 위의 원숭이 패치에서 odo로 전환하는 데 몇 시간을 보냈습니다. 일반 팬더 런타임은 RBAR 10시간 이상이었습니다. 원숭이 패치는 동일한 데이터 세트에서 2로 실행됩니다.
odo/CSV 경로는 예상대로 더 빨랐지만 노력할 가치가 충분하지는 않았습니다. 나는 원숭이 패치를 피한다는 명목으로 별로 신경 쓰지 않은 CSV 변환 문제를 만지작거렸다. NLP 분석을 위해 ~10개의 mysql 및 PG DB에서 Postgres의 공통 영역으로 250K 행을 가져오고 있습니다.

저는 대량 로딩 접근 방식에 대해 매우 잘 알고 있습니다. 나는 CSV 데이터로 시작하는 몇 년 동안 그것들을 사용해 왔습니다. 다음과 같은 주요 제한 사항이 있습니다.

1. df->CSV->Postgres의 경우 PG 호스트에서 CSV를 가져오려면 셸 액세스 및 scp 단계가 필요합니다. @mangecoeur 가 STDIN으로의 스트림으로 이 문제를 해결한 것 같습니다.
2. 내 목적을 위해(텍스트 내용에 많은 특별한 경우가 포함된 250K 행의 주석) CSV 매개변수를 올바르게 가져오는 데 어려움을 겪었습니다. 나는 이것에 계속 투자할 만큼 성능 향상을 원하지 않았습니다.

분석 작업을 계속할 수 있도록 패치로 다시 전환합니다.

@jorisvandenbossche , @maxgrenderjones에 동의합니다. 이것을 선택하는 옵션(기본값 아님)은 매우 유용할 것입니다. dialect.supports_multivalues_insert에 대한 @artemyk 의 요점은 이것을 합리적인 기본값으로 만들 수도 있습니다.

그것이 앞으로 나아갈 수 있다면 PR을 제출하게 되어 기쁩니다.

odo에 대한 내 경험을 추가하기 위해 인코딩과 관련된 알려진 문제로 인해 MS SQL 대량 삽입에서는 작동하지 않았습니다. imho m-row 삽입물은 대부분의 ppl을 위한 좋은 실용적인 솔루션입니다.

@markschwarz 더 빠르게 작동하도록 하는 옵션은 매우 환영합니다!

sqlite를 사용하여 쿼리를 추적하면 chunksize 를 사용할 때 다중 삽입에 들어가는 것 같습니다.

2017-09-28 00:21:39,007 INFO sqlalchemy.engine.base.Engine INSERT INTO country_hsproduct_year (location_id, product_id, year, export_rca, import_value, cog, export_value, distance, location_level, product_level) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
2017-09-28 00:21:39,007 INFO sqlalchemy.engine.base.Engine ((75, 1237, 1996, 1.7283086776733398, 273487116.0, 0.0, 514320160.0, 0.5413745641708374, 'country', '4digit'), (75, 1237, 1997, 1.7167805433273315, 312047528.0, 0.0, 592372864.0, 0.5314807891845703, 'country', '4digit'), (75, 1237, 1998, 1.2120152711868286, 341676961.0, 0.0, 468860608.0, 0.5472233295440674, 'country', '4digit'), (75, 1237, 1999, 1.236651062965393, 334604240.0, 0.0, 440722336.0, 0.5695921182632446, 'country', '4digit'), (75, 1237, 2000, 1.189828872680664, 383555023.0, 0.0, 426384832.0, 0.5794379711151123, 'country', '4digit'), (75, 1237, 2001, 0.9920380115509033, 374157144.0, 0.3462945520877838, 327031392.0, 0.6234743595123291, 'country', '4digit'), (75, 1237, 2002, 1.0405025482177734, 471456583.0, 0.0, 377909376.0, 0.6023964285850525, 'country', '4digit'), (75, 1237, 2003, 1.147829532623291, 552441401.0, 0.0, 481313504.0, 0.5896202325820923, 'country', '4digit')  ... displaying 10 of 100000 total bound parameter sets ...  (79, 1024, 2015, 0.0, None, 0.8785018920898438, 0.0, 0.9823430776596069, 'country', '4digit'), (79, 1025, 1995, 0.0, None, 0.5624096989631653, 0.0, 0.9839603304862976, 'country', '4digit'))

(원숭이 패치 없이, 즉)

흥미롭게도 원숭이 패치를 사용하면 10^5의 청크 크기를 제공하지만 10^3은 제공하지 않으면 중단됩니다. 오류는 sqlite에서 "너무 많은 SQL 변수"입니다.

@makmanalp , 아직 그 동작을 확인하기 위해 PG를 추적하지 않았지만 거의 항상 삽입 시 chunksize를 설정합니다. 위의 예에서 무작위로 200-5000 사이의 5개 값으로 설정했습니다. 나는 원숭이 패치 없이 그 선택들 사이에서 급격한 경과 시간 차이를 보지 못했습니다. 패치로 경과 시간이 ~80% 감소했습니다.

https://github.com/pandas-dev/pandas/issues/8953#issuecomment -76139975

이 원숭이 패치가 여전히 작동합니까? MS SQL Server에서 시도했지만 개선되지 않았습니다. 또한 예외가 발생합니다.

(pyodbc.Error) ('07002', '[07002] [Microsoft][SQL Server Native Client 11.0]COUNT field incorrect or syntax error (0) (SQLExecDirectW)')

@hangyao 나는 패치가 구현에 따라 다르다고 생각하는데, 파이썬 DBAPI가 처리하는 방법에 대해 DBAPI 드라이버에 남겨두는 것 중 하나입니다. 따라서 더 빠를 수도 있고 그렇지 않을 수도 있습니다. RE: 구문 오류, 확실하지 않습니다.

/io/sql.py 파일의 /io/sql.py 파일에 _engine_builder 함수를 라인 521에 있는 새 IF 구문에 추가하여 'new' _engine_builder 를 아래에 추가하는 것에 대해 생각하고 있습니다. 단편. 내 환경에서 간단히 테스트했으며 MSSQL 데이터베이스에서 훌륭하게 작동하여 100배 이상의 속도 향상을 달성했습니다. 다른 데이터베이스에서는 아직 테스트하지 않았습니다.

제가 PR을 하지 않는 것은 아래와 같이 그냥 삽입하는 것보다 깔끔하고 안전하게 만드는 것이 더 많은 노력이라고 생각합니다. 이것이 항상 원하는 사양은 아닐 수도 있고 이 설정을 켜고 끄는 boolean 스위치를 추가하는 것입니다. , (예: fast_executemany=True ) to_sql 는 묻지 않고 하기에는 너무 큰 노력인 것 같습니다.

그래서 내 질문은 다음과 같습니다.

• 아래 기능이 작동하고 PostgreSQL의 INSERT 속도도 증가합니까?

• 팬더 이벤트가 소스에 이 스니펫을 원합니까? 그렇다면:

• 이 기능을 기본 sql.py 기능에 추가하고 싶습니까? 아니면 이것을 추가하기에 더 좋은 곳이 있습니까?

의견을 듣고 싶습니다.

답변 출처: https://stackoverflow.com/questions/48006551/speeding-up-pandas-dataframe-to-sql-with-fast-executemany-of-pyodbc/48861231#48861231

@event.listens_for(engine, 'before_cursor_execute')
def receive_before_cursor_execute(conn, cursor, statement, params, context, executemany):
    if executemany:
        cursor.fast_executemany = True

def _engine_builder(con):
    """
    Returns a SQLAlchemy engine from a URI (if con is a string)
    else it just return con without modifying it.
    """
    global _SQLALCHEMY_INSTALLED
    if isinstance(con, string_types):
        try:
            import sqlalchemy
        except ImportError:
            _SQLALCHEMY_INSTALLED = False
        else:
            con = sqlalchemy.create_engine(con)

    @event.listens_for(engine, 'before_cursor_execute')
    def receive_before_cursor_execute(conn, cursor, statement, params, context, executemany):
        if executemany:
            cursor.fast_executemany = True
return con

@tsktsktsk123 최근 이에 관련된 PR 병합이 있었습니다: https://github.com/pandas-dev/pandas/pull/19664. 나는 아직 귀하의 게시물을 자세히 살펴보지 않았으며 확실히 동일하지는 않지만(sqlalchemy 엔진의 supports_multivalues_insert 속성을 사용함) 이것이 이미 도움이 될 경우에 대비하여 알고 있는지 확인하기 위한 것입니다. 또한.

좋은 소식입니다! 나는 PR을 살펴보지 않았지만 이번 주말에 그것을 비교하고 결과로 돌아올 것입니다. 감사합니다.

방금 0.23.0 RC2(postgresql에서)를 시도하고 있었고 성능 향상 대신 스크립트가 상당히 느려졌습니다. DB 쿼리는 훨씬 빨라졌지만 to_sql() 시간을 측정하면 실제로 최대 1.5배 느려졌습니다(예: 7초에서 11초)...

방금 RC를 테스트했기 때문에 속도 저하가 이 PR에서 비롯된 것인지 확실하지 않습니다.

다른 사람이 같은 문제를 겪었습니까?

@schettino72 얼마나 많은 데이터를 삽입하셨나요?

10개의 열이 있는 약 30,000개의 행. 그러나 실제로 내가 시도하는 거의 모든 것이 더 느립니다(SQL은 더 빠르지만 전반적으로 느림). 모든 값에 대한 값 보간이 있는 거대한 SQL 문을 생성하고 있습니다. 같은 것

 %(user_id_m32639)s, %(event_id_m32639)s, %(colx_m32639)s,

d6tstack 사용이 훨씬 간단하다는 것을 알았습니다. 한 줄 d6tstack.utils.pd_to_psql(df, cfg_uri_psql, 'benchmark', if_exists='replace') 이며 df.to_sql() 보다 훨씬 빠릅니다. 포스트그레스와 mysql을 지원합니다. https://github.com/d6t/d6tstack/blob/master/examples-sql.ipynb 참조

나는 원숭이 패치 솔루션을 사용하고 있습니다:

from pandas.io.sql import SQLTable

def _execute_insert(self, conn, keys, data_iter):
    print "Using monkey-patched _execute_insert"
    data = [dict((k, v) for k, v in zip(keys, row)) for row in data_iter]
    conn.execute(self.insert_statement().values(data))

SQLTable._execute_insert = _execute_insert

잠시 동안이지만 지금은 오류가 발생합니다.

TypeError: insert_statement() missing 2 required positional arguments: 'data' and 'conn'

다른 사람이 이것을 받고 있습니까? 저는 Python 3.6.5(Anaconda) 및 pandas==0.23.0을 사용 중입니다.

이거 고쳐지나요? 현재 df.to_sql은 매우 느리고 많은 실제 사용 사례에서 전혀 사용할 수 없습니다. Odo 프로젝트는 이미 포기한 것 같습니다.
df.to_sql을 거의 사용할 수 없는 금융 시계열에서 다음 사용 사례가 있습니다.
1) 과거 csv 데이터를 postgres 데이터베이스에 복사 - df.to_sql을 사용할 수 없으며 psycopg2 copy_from 기능에 대한 사용자 정의 코드를 사용해야 했습니다.
2) postgres 데이터베이스에 덤프될 스트리밍 데이터(초당 ~500-3000행의 일괄 처리로 제공됨) - 이러한 자연적인 데이터 일괄 처리를 postgres에 삽입하는 데 너무 많은 시간이 걸리기 때문에 다시 df.to_sql 성능은 상당히 실망스럽습니다.
내가 지금 df.to_sql이 유용하다고 생각하는 유일한 장소는 자동으로 테이블을 생성하는 것입니다!!! - 설계된 사용 사례가 아닙니다.
다른 사람들도 같은 문제를 공유하는지 확실하지 않지만 이 문제는 "데이터프레임-데이터베이스" 인터페이스가 원활하게 작동하려면 약간의 주의가 필요합니다.
기대해.

SQLite 데이터베이스에 다중 삽입을 수행하려고 할 때 이 오류가 발생합니다.

이것은 내 코드입니다.
df.to_sql("financial_data", con=conn, if_exists="append", index=False, method="multi")

이 오류가 발생합니다.

Traceback (most recent call last):

  File "<ipython-input-11-cf095145b980>", line 1, in <module>
    handler.insert_financial_data_from_df(data, "GOOG")

  File "C:\Users\user01\Documents\Code\FinancialHandler.py", line 110, in insert_financial_data_from_df
    df.to_sql("financial_data", con=conn, if_exists="append", index=False, method="multi")

  File "C:\Users\user01\AppData\Local\Continuum\anaconda3\lib\site-packages\pandas\core\generic.py", line 2531, in to_sql
    dtype=dtype, method=method)

  File "C:\Users\user01\AppData\Local\Continuum\anaconda3\lib\site-packages\pandas\io\sql.py", line 460, in to_sql
    chunksize=chunksize, dtype=dtype, method=method)

  File "C:\Users\user01\AppData\Local\Continuum\anaconda3\lib\site-packages\pandas\io\sql.py", line 1547, in to_sql
    table.insert(chunksize, method)

  File "C:\Users\user01\AppData\Local\Continuum\anaconda3\lib\site-packages\pandas\io\sql.py", line 686, in insert
    exec_insert(conn, keys, chunk_iter)

  File "C:\Users\user01\AppData\Local\Continuum\anaconda3\lib\site-packages\pandas\io\sql.py", line 609, in _execute_insert_multi
    conn.execute(self.table.insert(data))

TypeError: insert() takes exactly 2 arguments (1 given)

왜 이런 일이 발생합니까? 저는 Python 3.7.3(Anaconda), pandas 0.24.2 및 sqlite3 2.6.0을 사용하고 있습니다.

미리 대단히 감사합니다!

@jconstanzo 이 문제를 새 문제로 열 수 있습니까?
그리고 가능하다면 재현 가능한 예를 제공할 수 있습니까? (예: 문제를 보여줄 수 있는 작은 예제 데이터 프레임)

@jconstanzo 여기에 같은 문제가 있습니다. method='multi' (내 경우에는 chunksize 와 함께 사용)을 사용하면 SQLite 데이터베이스에 삽입하려고 할 때 이 오류가 발생하는 것 같습니다.

불행히도 내 데이터 세트가 거대하기 때문에 실제로 예제 데이터 프레임을 제공할 수 없습니다. 이것이 제가 처음에 method 및 chunksize 를 사용하는 이유입니다.

늦어서 죄송합니다. 방금 이 문제에 대한 문제를 열었습니다. https://github.com/pandas-dev/pandas/issues/29921