Pandas: उच्च विलंबता कनेक्शन पर to_sql पर बड़े पैमाने पर गति के लिए बहु-पंक्ति सम्मिलन का उपयोग करें

यह वाजिब लगता है। इसकी जांच के लिए धन्यवाद!

कार्यान्वयन के लिए, यह इस बात पर निर्भर करेगा कि कैसे sqlalchemy डेटाबेस स्वादों से संबंधित है जो इसका समर्थन नहीं करता है (मैं इस समय इसका परीक्षण नहीं कर सकता, लेकिन ऐसा लगता है कि sqlalchemy एक त्रुटि उठाता है (उदाहरण के लिए http://stackoverflow.com/questions/ 23886764/एकाधिक-सम्मिलित-कथन-में-mssql-साथ-sqlalchemy)। इसके अलावा, अगर इसका परिणाम यह है कि बहुत से लोगों को चंक्सेस सेट करना होगा, तो यह वास्तव में डिफ़ॉल्ट के रूप में करने के लिए एक अच्छा विचार नहीं है (जब तक कि हम सेट नहीं करते हैं डिफ़ॉल्ट रूप से एक मान के लिए खंडित करें)।
तो एक कीवर्ड जोड़ना शायद बेहतर लगता है।

@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)।

चूंकि इसमें बहुत तेजी से डालने की क्षमता है, और हम आसानी से समर्थन की जांच कर सकते हैं, मैं सोच रहा हूं कि हम इसे डिफ़ॉल्ट रूप से कर सकते हैं, और डिफ़ॉल्ट मान पर चंक्साइज भी सेट कर सकते हैं (उदाहरण के लिए 16kb भाग ... सुनिश्चित नहीं है कि क्या है ज्यादातर स्थितियों में बहुत बड़ा)। यदि मल्टीरो इंसर्ट विफल हो जाता है, तो हम चंक्ससाइज़ को कम करने का सुझाव देते हुए एक अपवाद फेंक सकते हैं?

अब मुझे SQLAlchemy लोगों को SQL सर्वर>2005 पर supports_multivalues_insert को सही पर सेट करने के लिए मनाने की आवश्यकता है (मैंने इसे कोड में हैक किया है और यह ठीक काम करता है, लेकिन यह डिफ़ॉल्ट रूप से चालू नहीं है)।

एक और विषय पर नोट पर, मुझे लगता है कि खंड आकार मुश्किल हो सकता है। मेरे MySQL सेटअप पर (जिसे मैंने शायद बड़े पैकेट को अनुमति देने के लिए कॉन्फ़िगर किया है), मैं अपने SQLServer सेटअप पर चंक्ससाइज = 5000 सेट कर सकता हूं, 500 बहुत बड़ा था, लेकिन 100 ने ठीक काम किया। हालांकि, यह शायद सच है कि इस तकनीक से अधिकांश लाभ 100 से 1000 के बजाय एक बार में 1 पंक्ति डालने से आते हैं।

क्या होगा यदि chunksize=None का अर्थ "अनुकूल रूप से एक खंड चुनें"? 5000, 500, 50, 1 जैसा कुछ करने का प्रयास करें। उपयोगकर्ता एक खंड निर्दिष्ट करके इसे बंद कर सकते हैं। यदि इन प्रयासों का ओवरहेड बहुत बड़ा है, तो मुझे @maxgrenderjones सुझाव पसंद है: chunksize=10 chunksize=1 से बेहतर डिफ़ॉल्ट है।

उस आखिरी टिप्पणी पर " chunksize=10 chunksize=1 " से बेहतर डिफ़ॉल्ट है -> यह पूरी तरह से सच नहीं है जो मुझे लगता है। वर्तमान स्थिति _one_ एक्ज़ीक्यूट स्टेटमेंट करना है जिसमें मल्टीलाइन सिंगल-रो इंसर्ट स्टेटमेंट (जो कि 1 का एक हिस्सा नहीं है) शामिल हैं, जबकि chunksize=10 का मतलब हर बार एक मल्टी-रो के साथ बहुत सारे एक्ज़िक्यूट स्टेटमेंट करना होगा। डालें।
और मैं नहीं जानता कि क्या यह आवश्यक रूप से तेज़ है, लेकिन बहुत कुछ स्थिति पर निर्भर करता है। उदाहरण के लिए वर्तमान कोड और स्थानीय एसक्लाइट डेटाबेस के साथ:

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 कीवर्ड (अभी के लिए गलत के डिफ़ॉल्ट के साथ) के माध्यम से जोड़ने के साथ शुरू कर सकते हैं, और फिर हम बाद में हमेशा देख सकते हैं कि क्या हम इसे डिफ़ॉल्ट रूप से सक्षम कर सकते हैं?

@maxgrenderjones @nhockham इसे जोड़ने के लिए पीआर करने के इच्छुक हैं?

@jorisvandenbossche मुझे लगता है कि विशिष्ट प्रदर्शन प्रोफाइल को संबोधित करने के लिए कीवर्ड तर्क जोड़ना शुरू करना जोखिम भरा है। यदि आप गारंटी दे सकते हैं कि यह सभी मामलों में तेज़ है (यदि आवश्यक हो तो इसे इनपुट के आधार पर सर्वोत्तम विधि निर्धारित करके) तो आपको ध्वज की आवश्यकता नहीं है।

अलग-अलग डीबी-सेटअप में अलग-अलग प्रदर्शन अनुकूलन हो सकते हैं (अलग-अलग डीबी परफ प्रोफाइल, स्थानीय बनाम नेटवर्क, बड़ी मेमोरी बनाम तेज एसएसडी, आदि, आदि), यदि आप प्रत्येक के लिए कीवर्ड झंडे जोड़ना शुरू करते हैं तो यह एक गड़बड़ हो जाता है।

मैं प्रदर्शन विशिष्ट कार्यान्वयन को संबोधित करने के लिए SQLDatabase और SQLTable के उप-वर्ग बनाने का सुझाव दूंगा, उनका उपयोग ऑब्जेक्ट-ओरिएंटेड एपीआई के माध्यम से किया जाएगा। शायद एक "बैकएंड स्विचिंग" विधि को जोड़ा जा सकता है लेकिन स्पष्ट रूप से ओओ एपीआई का उपयोग करना बहुत आसान है, इसलिए यह शायद पहले से ही एक विशेष उपयोग-मामले के लिए अधिक है।

मैंने पोस्टग्रेज में बड़े डेटासेट लोड करने के लिए ऐसा उप-वर्ग बनाया है (यह वास्तव में सीएसवी में डेटा को सहेजने के लिए बहुत तेज़ है, फिर अंतर्निहित गैर-मानक कॉपी का उपयोग करें, जो कि इन्सर्ट का उपयोग करने की तुलना में एसक्यूएल कमांड से है, https://gist.github देखें। com/mangecoeur/1fbd63d4758c2ba0c470#file-pandas_postgres-py)। इसका उपयोग करने के लिए आप बस PgSQLDatabase(engine, <args>).to_sql(frame, name,<kwargs>) . करें

सिर्फ संदर्भ के लिए, मैंने मल्टीरो फीचर का उपयोग करके @jorisvandenbossche (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

साथ ही, मैं मानता हूं कि कीवर्ड पैरामीटर जोड़ना जोखिम भरा है। हालाँकि, मल्टीरो फीचर काफी मौलिक लगता है। साथ ही, 'मंकी-पैचिंग' शायद कीवर्ड पैरामीटर की तुलना में एपीआई परिवर्तनों के लिए अधिक मजबूत नहीं है।

जैसा कि मुझे संदेह था। मंकी पैचिंग वह समाधान नहीं है जिसका मैं सुझाव दे रहा था - बल्कि यह कि हम कई प्रदर्शन उन्मुख उपवर्गों को शिप करते हैं जिन्हें सूचित उपयोगकर्ता OO इंटरफ़ेस के माध्यम से उपयोग कर सकता है (बहुत सारे विकल्पों के साथ कार्यात्मक एपीआई लोड करने से बचने के लिए)

-----वास्तविक सन्देश-----
से: "आर्टेमी कोल्चिंस्की" सूचनाएं @github.com
भेजा गया: 26/‎02/‎2015 17:13
प्रति: "pydata/pandas" [email protected]
सीसी: "मंगेकोयूर" जॉन। चैम्बर्स[email protected]
विषय: पुन: [पंडों] to_sqlover उच्च विलंबता कनेक्शन (#8953) पर बड़े पैमाने पर गति के लिए बहु-पंक्ति सम्मिलन का उपयोग करें

सिर्फ संदर्भ के लिए, मैंने मल्टीरो फीचर का उपयोग करके @jorisvandenbossche (3 दिसंबर पोस्ट) द्वारा कोड चलाने का प्रयास किया। यह काफी धीमा है। तो यहाँ गति-व्यापार तुच्छ नहीं है:
[4] में: इंजन = create_engine ('स्क्लाइट: ///: मेमोरी:') #, इको = 'डीबग')

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

[6] में:

[6] में: %timeit df.to_sql('test_default', engine, if_exists='replace')
1 लूप, सर्वोत्तम 3: 1.05 सेकेंड प्रति लूप

[7] में:

[7] में: pandas.io.sql से SQLTable आयात करें

[8] में:

[8] में: def _execute_insert(self, conn, keys, data_iter):
...: डेटा = [तानाशाही ((के, वी) के लिए, वी ज़िप में (कुंजी, पंक्ति)) data_iter में पंक्ति के लिए]
...: conn.execute (self.insert_statement ()। मान (डेटा))
...:

[9] में: SQLTable._execute_insert = _execute_insert

[10] में:

[10] में: पुनः लोड (पीडी)
आउट [10]:

[11] में:

[11] में: %timeit df.to_sql('test_default', engine, if_exists='replace', chunksize=10)
1 लूप, सर्वश्रेष्ठ 3: 9.9 सेकंड प्रति लूप
साथ ही, मैं मानता हूं कि कीवर्ड पैरामीटर जोड़ना जोखिम भरा है। हालाँकि, मल्टीरो फीचर काफी मौलिक लगता है। साथ ही, 'मंकी-पैचिंग' शायद कीवर्ड पैरामीटर की तुलना में एपीआई परिवर्तनों के लिए अधिक मजबूत नहीं है।
-
इस ईमेल का सीधे उत्तर दें या इसे GitHub पर देखें।

प्रारंभिक टिकट शीर्षक के अनुसार, मुझे नहीं लगता कि यह दृष्टिकोण सभी मामलों में बेहतर होगा, इसलिए मैं इसे डिफ़ॉल्ट नहीं बनाऊंगा। हालांकि, इसके बिना, पांडा to_sql मेरे लिए अनुपयोगी हैं, इसलिए मेरे लिए परिवर्तन का अनुरोध करना जारी रखना काफी महत्वपूर्ण है। (जब मैं अपने पांडा संस्करण को अपग्रेड करता हूं तो यह पहली चीज बन जाती है)। समझदार chunksize मूल्यों के लिए, मुझे नहीं लगता कि एक सही n है, क्योंकि पैकेट का आकार इस बात पर निर्भर करेगा कि कितने कॉलम हैं (और उनमें क्या है) भविष्यवाणी करने के तरीकों में मुश्किल है . दुर्भाग्य से SQLServer एक त्रुटि संदेश के साथ विफल हो जाता है जो पूरी तरह से असंबंधित दिखता है (लेकिन नहीं है) यदि आप chunksize बहुत अधिक सेट करते हैं (शायद यही कारण है कि SQLAlchemy में एक पैच को छोड़कर मल्टीरो इंसर्ट चालू नहीं होते हैं), लेकिन यह mysql के साथ ठीक काम करता है। उपयोगकर्ताओं को यह निर्धारित करने के लिए प्रयोग करने की आवश्यकता हो सकती है कि n का कौन सा मूल्य स्वीकार्य रूप से बड़े पैकेट आकार में परिणामित हो सकता है (उनके बैकिंग डेटाबेस जो भी हो)। पंडों ने n को चुना है, इससे हमें कार्यान्वयन विवरण में जमीन मिलने की संभावना है, जितना हम चाहते हैं (यानी अधिकतम-संभव-अमूर्त SQLALchemy दृष्टिकोण से विपरीत दिशा)

संक्षेप में, मेरी सिफारिश होगी कि इसे एक कीवर्ड के रूप में जोड़ा जाए, इसके उपयोग के बारे में कुछ उपयोगी टिप्पणी के साथ। यह पहली बार नहीं होगा जब किसी कीवर्ड का उपयोग किसी कार्यान्वयन का चयन करने के लिए किया गया था (देखें: http://pandas.pydata.org/pandas-docs/dev/generated/pandas.DataFrame.apply.html) लेकिन वह शायद है' सबसे अच्छा उदाहरण नहीं है, क्योंकि मुझे इस बारे में पहला विचार नहीं है कि raw= का क्या अर्थ है, यहां तक ​​कि स्पष्टीकरण पढ़ने के बाद भी!

मैंने देखा है कि यह बहुत बड़ी मात्रा में स्मृति का भी उपभोग करता है। लगभग 700,000 पंक्तियों और 301 स्तंभों के साथ 1.6+ जीबी डेटाफ़्रेम की तरह डालने के दौरान लगभग 34 जीबी की आवश्यकता होती है! यह शीर्ष अक्षम की तरह है। ऐसा क्यों हो सकता है पर कोई विचार? यहाँ एक स्क्रीन क्लिप है:

हाय दोस्तों,
इस मुद्दे पर कोई प्रगति?

मैं to_sql का उपयोग करके लगभग 200K पंक्तियों को सम्मिलित करने का प्रयास कर रहा हूं लेकिन यह हमेशा के लिए लेता है और बड़ी मात्रा में स्मृति का उपभोग करता है! चंक्साइज़ का उपयोग करने से स्मृति में मदद मिलती है लेकिन फिर भी गति बहुत धीमी होती है।

एमएसएसक्यूएल डीबेस ट्रेस को देखकर मेरी धारणा यह है कि सम्मिलन वास्तव में उस समय एक पंक्ति में किया जाता है।

अब एकमात्र व्यवहार्य तरीका एक साझा फ़ोल्डर पर एक सीएसवी फ़ाइल को डंप करना और बल्क इंसर्ट का उपयोग करना है। लेकिन यह बहुत कष्टप्रद और सुरुचिपूर्ण है!

@andreacassioli आप मध्यस्थ CSV फ़ाइल के माध्यम से SQL डेटाबेस में डेटाफ़्रेम सम्मिलित करने के लिए odo का उपयोग कर सकते हैं। SQL डेटाबेस में CSV लोड करना देखें।

मुझे नहीं लगता कि आप ODBC का उपयोग करके BULK INSERT प्रदर्शन के करीब भी आ सकते हैं।

@ostrokach धन्यवाद, वास्तव में मैं अब सीएसवी फाइलों का उपयोग कर रहा हूं। अगर मैं पास हो पाता, तो मैं सादगी के लिए थोड़ा समय देता!

मैंने सोचा कि यह किसी की मदद कर सकता है:
http://docs.sqlalchemy.org/hi/latest/faq/performance.html#i -m-inserting-400-000-rows-with-the-orm-and-it-s-really-slow

@indera पांडा ORM का उपयोग नहीं करते हैं, केवल sqlalchemy Core (जो कि वहाँ दस्तावेज़ प्रविष्टि है जो बड़े आवेषण के लिए उपयोग करने का सुझाव देती है)

इस बीच इस पर कैसे काम किया जाए, इस पर कोई सहमति है? मैं पोस्टग्रेज़ में कई मिलियन पंक्तियाँ सम्मिलित कर रहा हूँ और इसमें हमेशा के लिए लग जाता है। क्या सीएसवी/ओडो जाने का रास्ता है?

@russlamb इस समस्या को हल करने का एक व्यावहारिक तरीका केवल बल्क अपलोड करना है। हालांकि यह कोई डीबी विशिष्ट है, इसलिए 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)

क्या सीएसवी/ओडो जाने का रास्ता है?

बहु-पंक्ति/खंड आकार सेटिंग्स के बावजूद, यह समाधान लगभग हमेशा तेज़ होगा।

लेकिन, @russlamb , यह सुनना हमेशा दिलचस्प होता है कि क्या ऐसा बहु-पंक्ति कीवर्ड आपके मामले में सुधार करेगा। आसानी से इसका परीक्षण करने के तरीके पर https://github.com/pandas-dev/pandas/issues/8953#issuecomment -76139975 देखें।

मुझे लगता है कि इस बात पर सहमति है कि हम इसे निर्दिष्ट करने का एक तरीका चाहते हैं (आवश्यक रूप से डिफ़ॉल्ट को बदले बिना)। तो अगर कोई इसके लिए पीआर बनाना चाहता है, तो निश्चित रूप से उसका स्वागत है।
इस क्षमता को कैसे जोड़ा जाए (OO api का उपयोग करके नया कीवर्ड बनाम उपवर्ग) पर केवल कुछ चर्चा हुई।

@jorisvandenbossche मैंने ऊपर दिए गए दस्तावेज़ का उल्लेख किया है "वैकल्पिक रूप से, SQLAlchemy ORM विधियों के बल्क ऑपरेशंस सूट प्रदान करता है, जो कोर-स्तरीय INSERT का उत्सर्जन करने के लिए कार्य प्रक्रिया की इकाई के उपखंडों में हुक प्रदान करता है और ORM की एक छोटी डिग्री के साथ अद्यतन करता है। आधारित स्वचालन।"

मैं जो सुझाव दे रहा हूं वह to_sql के लिए एक एसक्लसेवर विशिष्ट संस्करण को कार्यान्वित करना है जो हुड के तहत ऊपर पोस्ट किए गए कोड में स्पीडअप के लिए SQLAlchemy ORM का उपयोग करता है।

यह पहले प्रस्तावित किया गया था। जिस तरह से आप जाते हैं वह एक पांडा वर्ग को लागू करना है
बैकएंड के लिए अनुकूलित वर्ग। मैंने अतीत में उपयोग करने के लिए एक सार पोस्ट किया था
कमांड से कॉपी पोस्ट करता है जो बहुत तेज है। हालांकि कुछ ऐसा ही
अब ओडो में उपलब्ध है, और अधिक मजबूत तरीके से बनाया गया है। बहुत कुछ नहीं है
ओडो से काम की नकल करने में आईएमएचओ को इंगित करें।

7 मार्च 2017 00:53 को, "आंद्रेई सुरा" नोटिफिकेशन @github.com ने लिखा:

@jorisvandenbossche https://github.com/jorisvandenbossche दस्तावेज़
मैंने ऊपर उल्लेख किया है "वैकल्पिक रूप से, SQLAlchemy ORM थोक प्रदान करता है"
विधियों का संचालन सूट, जो उपखंडों में हुक प्रदान करता है
कोर-लेवल INSERT और UPDATE का उत्सर्जन करने के लिए कार्य प्रक्रिया की इकाई
ओआरएम-आधारित स्वचालन की एक छोटी डिग्री के साथ निर्माण करता है।"

मैं जो सुझाव दे रहा हूं वह है sqlserver विशिष्ट संस्करण को लागू करना
"to_sql" जो हुड के नीचे स्पीडअप के लिए SQLAlchemy कोर का उपयोग करता है।

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपका उल्लेख किया गया था।
इस ईमेल का सीधे उत्तर दें, इसे GitHub पर देखें
https://github.com/pandas-dev/pandas/issues/8953#issuecomment-284437587 ,
या थ्रेड को म्यूट करें
https://github.com/notifications/unsubscribe-auth/AAtYVDXKLuTlsh9ycpMQvU5C0hs_RxuYks5rjCwBgaJpZM4DCjLh
.

यह भी देखा कि आपने उल्लेख किया है कि sqlalchemy इसके बजाय कोर हो सकता है। जब तक कुछ
बहुत कुछ बदल गया है, किसी भी मामले में केवल sqlalchemy कोर का उपयोग किया जाता है, कोई ओआरएम नहीं। अगर तुम
कोर का उपयोग करने से अधिक गति करना चाहते हैं, आपको निचले स्तर पर जाना होगा, डीबी
विशिष्ट अनुकूलन

7 मार्च 2017 00:53 को, "आंद्रेई सुरा" नोटिफिकेशन @github.com ने लिखा:

@jorisvandenbossche https://github.com/jorisvandenbossche दस्तावेज़
मैंने ऊपर उल्लेख किया है "वैकल्पिक रूप से, SQLAlchemy ORM थोक प्रदान करता है"
विधियों का संचालन सूट, जो उपखंडों में हुक प्रदान करता है
कोर-लेवल INSERT और UPDATE का उत्सर्जन करने के लिए कार्य प्रक्रिया की इकाई
ओआरएम-आधारित स्वचालन की एक छोटी डिग्री के साथ निर्माण करता है।"

मैं जो सुझाव दे रहा हूं वह है sqlserver विशिष्ट संस्करण को लागू करना
"to_sql" जो हुड के नीचे स्पीडअप के लिए SQLAlchemy कोर का उपयोग करता है।

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपका उल्लेख किया गया था।
इस ईमेल का सीधे उत्तर दें, इसे GitHub पर देखें
https://github.com/pandas-dev/pandas/issues/8953#issuecomment-284437587 ,
या थ्रेड को म्यूट करें
https://github.com/notifications/unsubscribe-auth/AAtYVDXKLuTlsh9ycpMQvU5C0hs_RxuYks5rjCwBgaJpZM4DCjLh
.

क्या इसे ठीक किया जा रहा है/इसका ध्यान रखा जा रहा है? जब तक यह एक खिलौना डेटाफ़्रेम न हो, तब तक SQL db में पांडा डेटाफ़्रेम सम्मिलित करना बेहद धीमा है। आइए एक समाधान पर निर्णय लें और इसे आगे बढ़ाएं?

@dfernan जैसा ऊपर बताया गया है, आप odo देखना चाहेंगे। एक मध्यस्थ सीएसवी फ़ाइल का उपयोग हमेशा परिमाण के आदेश तेजी से होगा जो कि sqlalchemy के माध्यम से जा रहा है, इससे कोई फर्क नहीं पड़ता कि यहां किस तरह का सुधार होता है ...

@ostrokach , मैं इस बात से सहमत नहीं हूं कि ओडो का व्यवहार वही है जो सामान्य पंडों का उपयोगकर्ता चाहता है। ODBC पर बहु-पंक्ति सम्मिलन संभवतः अधिकांश विश्लेषकों के लिए पर्याप्त तेज़ हैं।

अपने लिए बोलने के लिए, मैंने ऊपर के बंदर पैच से ओडो में स्विच करने में कुछ घंटे बिताए। सादा पांडा रनटाइम 10+ घंटे, आरबीएआर था। बंदर पैच एक ही डेटा सेट पर 2 में चलता है।
ओडो/सीएसवी मार्ग अपेक्षा के अनुरूप तेज़ था, लेकिन इतना नहीं कि इसे प्रयास के लायक बनाया जा सके। मैं सीएसवी रूपांतरण के मुद्दों से जूझ रहा था, जिसकी मुझे ज्यादा परवाह नहीं थी, सभी बंदर पैच से बचने के नाम पर। मैं एनएलपी विश्लेषण के लिए पोस्टग्रेज में एक सामान्य क्षेत्र में ~ 10 mysql और PG DBs से 250K पंक्तियों का आयात कर रहा हूं।

मैं थोक लोडिंग दृष्टिकोण odo espouses से अच्छी तरह परिचित हूं। मैंने उन्हें वर्षों से उपयोग किया है जहां मैं सीएसवी डेटा से शुरू कर रहा हूं। उनकी प्रमुख सीमाएँ हैं:

1. df->CSV-> पोस्टग्रेज केस के लिए, PG होस्ट पर CSV प्राप्त करने के लिए शेल एक्सेस और एक scp स्टेप की आवश्यकता होती है। ऐसा लगता है कि @mangecoeur STDIN की एक धारा के साथ इसके आसपास पहुंच गया है।
2. मेरे उद्देश्य के लिए (टिप्पणियों की 250K पंक्तियाँ, पाठ सामग्री में बहुत सारे विशेष मामलों के साथ) मैंने CSV मापदंडों को सही करने के लिए संघर्ष किया। मैं इसमें निवेश जारी रखने के लिए प्रदर्शन लाभ बुरी तरह से नहीं चाहता था।

मैं पैच पर वापस जाता हूं, ताकि मैं विश्लेषण कार्य पर जा सकूं।

मैं @jorisvandenbossche , @maxgrenderjones से सहमत हूं। इसे चुनने के लिए एक विकल्प (डिफ़ॉल्ट नहीं) बेहद उपयोगी होगा। @artemyk की बोली के बारे में बात।supports_multivalues_insert इसे एक उचित डिफ़ॉल्ट भी बना सकता है।

मुझे एक पीआर सबमिट करने में प्रसन्नता हो रही है यदि इससे इसे आगे बढ़ाया जा सके।

ओडो के साथ अपना अनुभव जोड़ने के लिए, एन्कोडिंग के साथ ज्ञात समस्या के कारण इसने एमएस एसक्यूएल थोक सम्मिलन के लिए काम नहीं किया है। इम्हो एम-रो इंसर्ट अधिकांश पीपीएल के लिए अच्छा व्यावहारिक समाधान है।

@markschwarz इसे तेजी से काम करने के लिए सक्षम करने का एक विकल्प बहुत स्वागत योग्य होगा!

एसक्लाइट का उपयोग करके प्रश्नों को ट्रेस करना, मुझे लगता है कि 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 नहीं। स्क्लाइट पर त्रुटि "बहुत अधिक एसक्यूएल चर" है।

@makmanalp , मैंने उस व्यवहार की जांच के लिए पीजी पर पता नहीं लगाया है, फिर भी, लेकिन मैं लगभग हमेशा सम्मिलित करने पर चंक्ससाइज सेट करता हूं। उपरोक्त मेरे उदाहरण में, मैंने इसे 200-5000 के बीच यादृच्छिक रूप से 5 मानों पर सेट किया है। मैंने बंदर पैच के बिना, उन विकल्पों के बीच भारी बीता हुआ समय अंतर नहीं देखा। पैच के साथ, बीता हुआ समय ~ 80% गिर गया।

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

क्या यह बंदर पैच अभी भी काम कर रहा है? मैंने इसे MS SQL सर्वर पर आज़माया लेकिन कोई सुधार नहीं देखा। इसके अलावा, यह एक अपवाद फेंकता है:

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

@hangyao मुझे लगता है कि पैच कार्यान्वयन-विशिष्ट है, उन चीजों में से एक है जो पाइथन डीबीएपीआई डीबीएपीआई ड्राइवर को संभालने के तरीके पर छोड़ देता है। तो यह तेज हो सकता है या नहीं। आरई: वाक्यविन्यास त्रुटि, इसके बारे में अनिश्चित।

मैं नीचे दिए गए फ़ंक्शन को /io/sql.py फ़ाइल में लाइन 507 में जोड़ने के बारे में सोच रहा हूं, _engine_builder फ़ंक्शन के भीतर लाइन 521 पर एक नए IF क्लॉज के भीतर 'नया' _engine_builder नीचे टुकड़ा। मैंने इसे अपने पर्यावरण पर संक्षेप में परीक्षण किया है और यह एमएसएसक्यूएल डेटाबेस के लिए बहुत अच्छा काम करता है,> 100x स्पीड-अप प्राप्त करता है। मैंने अभी तक अन्य डेटाबेस पर इसका परीक्षण नहीं किया है।

पीआर बनाने के लिए मुझे वापस लेने की बात यह है कि मुझे लगता है कि इसे नीचे की तरह डालने की तुलना में इसे साफ और सुरक्षित बनाने का अधिक प्रयास है, यह हमेशा वांछित युक्ति नहीं हो सकता है और एक बूलियन स्विच जोड़ सकता है, जो इस सेटिंग को चालू/बंद कर देता है , (उदाहरण के लिए fast_executemany=True ) to_sql में ऐसा लग रहा था कि बिना पूछे बस कुछ करना बहुत बड़ा प्रयास है, मुझे लगता है।

तो मेरे प्रश्न हैं:

• क्या नीचे दिया गया कार्य काम करता है और PostgreSQL के लिए INSERT गति भी बढ़ाता है?

• क्या पांडा घटना इस स्निपेट को अपने स्रोत में चाहती है? यदि ऐसा है तो:

• क्या इस फ़ंक्शन को डिफ़ॉल्ट sql.py कार्यक्षमता में जोड़ना वांछित है या इसे जोड़ने के लिए कोई बेहतर जगह है?

कुछ टिप्पणियाँ सुनना पसंद है।

उत्तर के लिए स्रोत :

@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 हाल ही में इससे संबंधित एक पीआर का विलय हुआ है: https://github.com/pandas-dev/pandas/pull/19664। मैंने अभी तक आपकी पोस्ट को विस्तार से नहीं देखा है, और यह निश्चित रूप से बिल्कुल समान नहीं है (यह sqlalchemy इंजन की supports_multivalues_insert विशेषता का उपयोग करता है), लेकिन यह सुनिश्चित करने के लिए कि आप इसके बारे में जानते हैं यदि यह पहले से ही मदद करता है भी।

यह तो बहुत अच्छी खबर है! मैंने पीआर में नहीं देखा है, लेकिन इस सप्ताह के अंत में इसकी तुलना करूंगा और परिणामों के साथ वापस आऊंगा। सर उठाने के लिए धन्यवाद।

मैं सिर्फ 0.23.0 आरसी 2 (पोस्टग्रेस्क्ल पर) की कोशिश कर रहा था और प्रदर्शन को बढ़ावा देने के बजाय मेरी स्क्रिप्ट को काफी धीमी गति मिली। डीबी क्वेरी बहुत तेज हो गई लेकिन to_sql() के लिए समय मापने से यह वास्तव में 1.5 गुना धीमी हो गई (जैसे 7 से 11 सेकेंड तक) ...

सुनिश्चित नहीं है कि इस पीआर से धीमापन आता है, हालांकि मैंने अभी आरसी का परीक्षण किया है।

किसी और ने भी इसी समस्या का अनुभव किया है?

@ schettino72 आप कितना डेटा डाल रहे थे?

10 कॉलम वाली लगभग 30K पंक्तियाँ। लेकिन वास्तव में मैं जो कुछ भी कोशिश करता हूं वह धीमा है (एसक्यूएल तेज है लेकिन कुल मिलाकर धीमा है)। यह एक विशाल 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'

क्या किसी और को यह मिल रहा है? मैं अजगर 3.6.5 (एनाकोंडा) और पांडा पर हूँ==0.23.0

क्या यह ठीक हो रहा है? वर्तमान में, df.to_sql बेहद धीमा है और कई व्यावहारिक उपयोग के मामलों के लिए इसका बिल्कुल भी उपयोग नहीं किया जा सकता है। ऐसा लगता है कि ओडो परियोजना पहले ही छोड़ दी गई है।
मेरे पास वित्तीय समय श्रृंखला में निम्नलिखित उपयोग के मामले हैं जहां df.to_sql बहुत अधिक प्रयोग करने योग्य नहीं है:
1) डेटाबेस को पोस्टग्रेज करने के लिए ऐतिहासिक सीएसवी डेटा की प्रतिलिपि बनाना - df.to_sql का उपयोग नहीं कर सकता और psycopg2 copy_from कार्यक्षमता के आसपास कस्टम कोड के साथ जाना पड़ा
2) स्ट्रीमिंग डेटा (~ 500-3000 पंक्तियों के एक बैच में प्रति सेकंड) को पोस्टग्रेज डेटाबेस में डंप किया जाना है - फिर से 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)

ऐसा क्यों हो रहा है? मैं पायथन 3.7.3 (एनाकोंडा), पांडा 0.24.2 और sqlite3 2.6.0 का उपयोग कर रहा हूं।

अग्रिम बहुत बहुत धन्यवाद!

@jconstanzo क्या आप इसे एक नए मुद्दे के रूप में खोल सकते हैं?
और यदि संभव हो, तो क्या आप एक प्रतिलिपि प्रस्तुत करने योग्य उदाहरण प्रदान करने का प्रयास कर सकते हैं? (उदाहरण के लिए एक छोटा सा उदाहरण डेटाफ्रेम जो समस्या दिखा सकता है)

@jconstanzo यहाँ एक ही समस्या है। जब आप SQLite डेटाबेस में डालने का प्रयास करते हैं तो method='multi' (मेरे मामले में, chunksize के संयोजन में) का उपयोग करना इस त्रुटि को ट्रिगर करने लगता है।

दुर्भाग्य से मैं वास्तव में एक उदाहरण डेटाफ्रेम प्रदान नहीं कर सकता क्योंकि मेरा डेटासेट बहुत बड़ा है, यही कारण है कि मैं पहले स्थान पर method और chunksize का उपयोग कर रहा हूं।

देरी के लिए माफी चाहता हूं। मैंने अभी इस समस्या के लिए एक मुद्दा खोला है: https://github.com/pandas-dev/pandas/issues/29921