Pandas: `.to_sql` में विकल्प जोड़ना (यदि कुंजी मौजूद है तो डालें या अपडेट करें)

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

हाँ, मुझे लगता है कि यह पांडा के दायरे से बाहर है क्योंकि अप्सर्ट सभी डीबी इंजनों द्वारा समर्थित नहीं हैं।

जबकि INSERT OR UPDATE सभी इंजनों द्वारा समर्थित नहीं है, डेटाफ़्रेम इंडेक्स में प्राथमिक कुंजियों के सेट के लिए लक्ष्य तालिका से पंक्तियों को हटाकर एक INSERT OR REPLACE को इंजन अज्ञेय बनाया जा सकता है, जिसके बाद एक इंसर्ट किया जा सकता है DataFrame में सभी पंक्तियाँ। आप इसे लेन-देन में करना चाहेंगे।

@TomAugspurger क्या हम समर्थित डीबी इंजन के लिए

मैं यह भी देखना चाहूंगा। मैं शुद्ध एसक्यूएल और एसक्यूएल कीमिया का उपयोग करने के बीच में फंस गया हूं (इसे अभी तक काम करने के लिए नहीं मिला है, मुझे लगता है कि इसका कुछ संबंध है कि मैं कैसे डिक्ट्स पास करता हूं)। मैं थोक डालने के लिए psycopg2 COPY का उपयोग करता हूं, लेकिन मुझे उन तालिकाओं के लिए pd.to_sql का उपयोग करना अच्छा लगेगा जहां समय के साथ मूल्य बदल सकते हैं और मुझे थोड़ा धीमा डालने में कोई फर्क नहीं पड़ता।

insert_values = df.to_dict(orient='records')
insert_statement = sqlalchemy.dialects.postgresql.insert(table).values(insert_values)
upsert_statement = insert_statement.on_conflict_do_update(
    constraint='fact_case_pkey',
    set_= df.to_dict(orient='dict')
)

और शुद्ध एसक्यूएल:

def create_update_query(df, table=FACT_TABLE):
    """This function takes the Airflow execution date passes it to other functions"""
    columns = ', '.join([f'{col}' for col in DATABASE_COLUMNS])
    constraint = ', '.join([f'{col}' for col in PRIMARY_KEY])
    placeholder = ', '.join([f'%({col})s' for col in DATABASE_COLUMNS])
    values = placeholder
    updates = ', '.join([f'{col} = EXCLUDED.{col}' for col in DATABASE_COLUMNS])
    query = f"""INSERT INTO {table} ({columns}) 
    VALUES ({placeholder}) 
    ON CONFLICT ({constraint}) 
    DO UPDATE SET {updates};"""
    query.split()
    query = ' '.join(query.split())
    return query

def load_updates(df, connection=DATABASE):
    """Uses COPY from STDIN to load to Postgres
     :param df: The dataframe which is writing to StringIO, then loaded to the the database
     :param connection: Refers to a PostgresHook
    """
    conn = connection.get_conn()
    cursor = conn.cursor()
    df1 = df.where((pd.notnull(df)), None)
    insert_values = df1.to_dict(orient='records')
    for row in insert_values:
        cursor.execute(create_update_query(df), row)
        conn.commit()
    cursor.close()
    del cursor
    conn.close()

@ldacey इस शैली ने मेरे लिए काम किया (insert_statement.excluded डेटा की पंक्ति के लिए एक उपनाम है जो बाधा का उल्लंघन करता है):

insert_values = merged_transactions_channels.to_dict(orient='records')
 insert_statement = sqlalchemy.dialects.postgresql.insert(orders_to_channels).values(insert_values)
    upsert_statement = insert_statement.on_conflict_do_update(
        constraint='orders_to_channels_pkey',
        set_={'channel_owner': insert_statement.excluded.channel_owner}
    )

@cdagnino समग्र कुंजी के मामले में यह स्निपेट काम नहीं कर सकता है, उस परिदृश्य का भी ध्यान रखना होगा। मैं ऐसा करने का एक तरीका खोजने की कोशिश करूंगा

इस अद्यतन समस्या को हल करने का एक तरीका sqlachemy के बल्क_अपडेट_मैपिंग का उपयोग

session.bulk_update_mappings(
  Table,
  pandas_df.to_dict(orient='records)
)

मैं @neilfrndes से सहमत

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

एक संभावना यह है कि अगर यह पीआर पेश किया जाता है तो method कॉल करने योग्य अप्सर्ट के लिए कुछ उदाहरण प्रदान करना है: https://github.com/pandas-dev/pandas/pull/21401

पोस्टग्रेज़ के लिए जो कुछ ऐसा दिखाई देगा (अवांछित):

from sqlalchemy.dialects import postgresql

def pg_upsert(table, conn, keys, data_iter):
    for row in data:
        row_dict = dict(zip(keys, row))
        stmt = postgresql.insert(table).values(**row_dict)
        upsert_stmt = stmt.on_conflict_do_update(
            index_elements=table.index,
            set_=row_dict)
        conn.execute(upsert_stmt)

MySQL के लिए कुछ ऐसा ही किया जा सकता है।

पोस्टग्रेज के लिए मैं execute_values ​​​​का उपयोग कर रहा हूं। मेरे मामले में, मेरी क्वेरी ध्वजांकित करने के लिए एक jinja2 टेम्प्लेट है कि मुझे अपडेट सेट करना चाहिए या कुछ नहीं करना चाहिए। यह काफी तेज और लचीला रहा है। COPY या copy_expert का उपयोग करने जितना तेज़ नहीं है, लेकिन यह अच्छी तरह से काम करता है।

from psycopg2.extras import execute_values

df = df.where((pd.notnull(df)), None)
tuples = [tuple(x) for x in df.values]

`` with pg_conn: with pg_conn.cursor() as cur: execute_values(cur=cur, sql=insert_query, argslist=tuples, template=None, )

@ danich1 क्या आप कृपया एक उदाहरण सेट कर सकते हैं कि यह कैसे काम करेगा?

मैंने बल्क_अपडेट_मैपिंग पर एक नज़र डालने की कोशिश की लेकिन मैं वास्तव में खो गया और इसे काम नहीं कर सका।

@ cristianionescu92 एक उदाहरण यह होगा:
मेरे पास निम्न फ़ील्ड वाले उपयोगकर्ता नामक एक टेबल है: आईडी और नाम।

| आईडी | नाम |
| --- | --- |
| 0 | जॉन |
| 1 | जो |
| 2 | हैरी |

मेरे पास एक ही कॉलम के साथ एक पांडा डेटा फ्रेम है लेकिन अद्यतन मान हैं:

| आईडी | नाम |
| --- | --- |
| 0 | क्रिस |
| 1 | जेम्स |

आइए यह भी मान लें कि हमारे पास डेटाबेस तक पहुंचने के लिए एक सत्र चर खुला है। इस विधि को कॉल करके:

session.bulk_update_mappings(
User,
<pandas dataframe above>.to_dict(orient='records')
)

पांडा टेबल को शब्दकोशों की सूची में बदल देंगे [{id: 0, name: "chris"}, {id: 1, name:"james"}] जिसका इस्तेमाल sql टेबल की पंक्तियों को अपडेट करने के लिए करेगा। तो अंतिम तालिका इस तरह दिखेगी:

| आईडी | नाम |
| --- | --- |
| 0 | क्रिस |
| 1 | जेम्स |
| 2 | हैरी |

नमस्ते, @ danich1 और आपकी प्रतिक्रिया के लिए बहुत-बहुत धन्यवाद। मैंने खुद को यांत्रिकी समझ लिया कि अपडेट कैसे काम करेगा। दुर्भाग्य से मुझे नहीं पता कि सत्र के साथ कैसे काम करना है, मैं काफी शुरुआत कर रहा हूं।

मैं आपको दिखाता हूं कि मैं क्या कर रहा हूं:

`आयात pypyodbc
to_sql_newrows से clean_df_db_dups आयात करें, to_sql_newrows # ये 2 फ़ंक्शन हैं जो मुझे GitHub पर मिले, दुर्भाग्य से मुझे लिंक याद नहीं है। Clean_df_db_dups एक डेटाफ़्रेम से उन पंक्तियों को बाहर करता है जो पहले से ही SQL तालिका में कई प्रमुख स्तंभों की जाँच करके मौजूद हैं और to_sql_newrows एक ऐसा फ़ंक्शन है जो sql में नई पंक्तियों को सम्मिलित करता है।

from sqlalchemy import create_engine
engine = create_engine("engine_connection_string")

#Write data to SQL
Tablename = 'Dummy_Table_Name'
Tablekeys = Tablekeys_string
dftoupdateorinsertinSQL= random_dummy_dataframe

#Connect to sql server db using pypyodbc
cnxn = pypyodbc.connect("Driver={SQL Server};"
                        "Server=ServerName;"
                        "Database=DatabaseName;"
                        "uid=userid;pwd=password")

newrowsdf= clean_df_db_dups(dftoupdateorinsertinSQL, Tablename, engine, dup_cols=Tablekeys)
newrowsdf.to_sql(Tablename, engine, if_exists='append', index=False, chunksize = 140)
end=timer()

tablesize = (len(newrowsdf.index))

print('inserted %r rows '%(tablesize))`

उपरोक्त कोड मूल रूप से उन पंक्तियों को डेटाफ्रेम से बाहर कर रहा है जो मेरे पास पहले से SQL में हैं और केवल नई पंक्तियों को सम्मिलित करता है। मुझे जो चाहिए वह मौजूद पंक्तियों को अद्यतन करना है। क्या आप कृपया मुझे यह समझने में मदद कर सकते हैं कि मुझे आगे क्या करना चाहिए?

एक बेहतर TO_SQL के लिए प्रेरणा
to_sql डेटाबेस प्रथाओं के साथ बेहतर एकीकरण का महत्व बढ़ रहा है क्योंकि डेटा विज्ञान बढ़ता है और डेटा इंजीनियरिंग के साथ मिश्रित हो जाता है।

upsert उनमें से एक है, विशेष रूप से क्योंकि बहुत से लोग पाते हैं कि इसके बजाय replace उपयोग करना है, जो तालिका को छोड़ देता है, और इसके साथ सभी विचार और बाधाएं हैं।

अधिक अनुभवी उपयोगकर्ताओं में मैंने जो विकल्प देखा है, वह इस स्तर पर पांडा का उपयोग करना बंद करना है, और यह अपस्ट्रीम का प्रचार करता है और पांडा पैकेज को अनुभवी उपयोगकर्ताओं के बीच ढीला रखता है। क्या यही वह दिशा है जहां पंडों जाना चाहते हैं?

मैं समझता हूं कि हम जितना संभव हो सके डेटाबेस अज्ञेयवादी बने रहना चाहते हैं, और कोर एसक्यूएल कीमिया का उपयोग करना चाहते हैं। एक विधि जो एक सच्चे अप्सर्ट के बजाय काट-छाँट या हटा देती है, फिर भी बहुत अधिक मूल्य जोड़ देगी।

पांडा उत्पाद दृष्टि के साथ एकीकरण
उपरोक्त बहुत सी बहस method तर्क (जैसा कि @kjford द्वारा psql_insert_copy साथ उल्लेख किया गया है) और एक कॉल करने योग्य पर पारित होने की संभावना से पहले हुई थी।

मैं खुशी से या तो मूल पांडा कार्यक्षमता में योगदान देता हूं, या असफल रहा हूं, पंडों के भीतर एक ऊपरी कार्यक्षमता प्राप्त करने के तरीके पर समाधान/सर्वोत्तम अभ्यास पर दस्तावेज, जैसे कि नीचे:
https://pandas.pydata.org/pandas-docs/stable/user_guide/io.html#io -sql-method

पंडों के कोर देव / उत्पाद प्रबंधकों के लिए पसंदीदा तरीका क्या है?

मुझे लगता है कि हम एक कार्यान्वयन के लिए खुले हैं जो इंजन-विशिष्ट है। method='upsert' का उपयोग करने का प्रस्ताव उचित लगता है, लेकिन इस बिंदु पर मुझे लगता है कि हमें स्पष्ट डिजाइन प्रस्ताव के साथ आने के लिए किसी की आवश्यकता है।

मेरे पास एक समान आवश्यकता है जहां मैं समय के साथ एकाधिक सीएसवी से एक MySQL तालिका में मौजूदा डेटा अपडेट करना चाहता हूं।

मैंने सोचा कि मैं एक नई बनाई गई अस्थायी तालिका में नया डेटा डालने के लिए df.to_sql() कर सकता हूं और फिर मौजूदा तालिका में डेटा को जोड़ने/अपडेट करने के तरीके को नियंत्रित करने के लिए एक MySQL क्वेरी चला सकता हूं।

MySQL संदर्भ: https://stackoverflow.com/questions/2472229/insert-into-select-from-on-duplicate-key-update?answertab=active#tab -top

अस्वीकरण: मैंने कुछ दिन पहले ही पायथन और पंडों का उपयोग करना शुरू किया था।

हे पंडों के लोग: मेरे पास भी यही मुद्दा है, मुझे अपने स्थानीय डेटाबेस को रिकॉर्ड के साथ बार-बार अपडेट करने की आवश्यकता है जिसे मैं अंततः पंडों में लोड और हेरफेर करता हूं। मैंने ऐसा करने के लिए एक साधारण पुस्तकालय बनाया - यह मूल रूप से df.to_sql और pd.read_sql_table के लिए एक स्टैंड-इन है जो डिफ़ॉल्ट रूप से प्राथमिक कुंजी के रूप में डेटाफ़्रेम अनुक्रमणिका का उपयोग करता है। केवल sqlalchemy कोर का उपयोग करता है।

https://pypi.org/project/pandabase/0.2.1/
Https://github.com/notsambeck/pandabase

यह उपकरण काफी राय वाला है, शायद पंडों में शामिल करने के लिए उपयुक्त नहीं है। लेकिन मेरे विशिष्ट उपयोग के मामले में यह समस्या को हल करता है ... अगर इसे पंडों में फिट करने के लिए मालिश करने में रुचि है तो मुझे मदद करने में खुशी होगी।

अभी के लिए, निम्नलिखित कार्य (वर्तमान-ईश पांडा और स्क्लेल्केमी के सीमित मामले में, प्राथमिक कुंजी के रूप में नामित अनुक्रमणिका, SQLite या पोस्टग्रेस बैक एंड, और समर्थित डेटाटाइप):

पाइप स्थापित पांडाबेस / pandabase.to_sql (df, table_name, con_string, कैसे = 'अपसर्ट')

cvonsteg के साथ इसके सामान्य समाधान पर कार्य करना। अक्टूबर में प्रस्तावित डिजाइन के साथ वापस आने की योजना है।

@TomAugspurger जैसा कि सुझाव दिया गया है, @rugg2 और मैं upsert में to_sql() upsert विकल्प के लिए निम्नलिखित डिज़ाइन प्रस्ताव लेकर आए हैं।

इंटरफ़ेस प्रस्ताव

to_sql() विधि में संभावित method तर्क के रूप में जोड़े जाने वाले 2 नए चर:
1) upsert_update - पंक्ति मिलान पर, डेटाबेस में अद्यतन पंक्ति (जानबूझकर रिकॉर्ड अपडेट करने के लिए - अधिकांश उपयोग मामलों का प्रतिनिधित्व करता है)
2) upsert_ignore - पंक्ति मिलान पर, डेटाबेस में पंक्ति को अपडेट न करें (उन मामलों के लिए जहां डेटासेट ओवरलैप हैं, और आप तालिकाओं में डेटा को ओवरराइड नहीं करना चाहते हैं)

import pandas as pd
from sqlalchemy import create_engine

engine = create_engine("connection string")
df = pd.DataFrame(...)

df.to_sql(
    name='table_name', 
    con=engine, 
    if_exists='append', 
    method='upsert_update' # (or upsert_ignore)
)

कार्यान्वयन प्रस्ताव

इसे लागू करने के लिए, SQLTable वर्ग को अप्सर्ट लॉजिक वाली 2 नई निजी विधियां प्राप्त होंगी, जिन्हें SQLTable.insert() विधि से बुलाया जाएगा:

def insert(self, chunksize=None, method=None):

    #set insert method
    if method is None:
        exec_insert = self._execute_insert
    elif method == "multi":
        exec_insert = self.execute_insert_multi
    #new upsert methods <<<
    elif method == "upsert_update":
        exec_insert = self.execute_upsert_update
    elif method == "upsert_ignore":
        exec_insert = self.execute_upsert_ignore
    # >>>
    elif callable(method):
        exec_inset = partial(method, self)
    else:
        raise ValueError("Invalid parameter 'method': {}".format(method))

    ...

हम निम्नलिखित कार्यान्वयन का प्रस्ताव करते हैं, नीचे विस्तार से उल्लिखित तर्क के साथ (सभी बिंदु चर्चा के लिए खुले हैं):

(1) DELETE और INSERT परमाणु अनुक्रम के माध्यम से SQLAlchemy कोर का उपयोग कर इंजन अज्ञेयवादी

• केवल कुछ डीबीएमएस मूल रूप से upsert समर्थन करते हैं, और कार्यान्वयन स्वादों में भिन्न हो सकते हैं
• पहले कार्यान्वयन के रूप में हम मानते हैं कि सभी डीबीएमएस में एक कार्यान्वयन का परीक्षण और रखरखाव करना आसान होगा। भविष्य में, यदि मांग मौजूद है, तो इंजन-विशिष्ट कार्यान्वयन को जोड़ा जा सकता है।
• upsert_ignore इन कार्यों को स्पष्ट रूप से मिलान रिकॉर्ड पर छोड़ दिया जाएगा
• प्रदर्शन के मामले में इंजन-अज्ञेय कार्यान्वयन बनाम इंजन-विशिष्ट कार्यान्वयन की तुलना करना उचित होगा।

(२) केवल प्राथमिक कुंजी पर अप्सर्ट करें

• जब तक अन्यथा निर्दिष्ट नहीं किया जाता है, तब तक प्राथमिक कुंजी क्लैश के लिए अप्सर्ट डिफ़ॉल्ट होते हैं
• कुछ डीबीएमएस उपयोगकर्ताओं को गैर-प्राथमिक-कुंजी कॉलम निर्दिष्ट करने की अनुमति देते हैं, जिसके विरुद्ध विशिष्टता की जांच की जाती है। जबकि यह उपयोगकर्ता को अधिक लचीलापन देता है, यह संभावित नुकसान के साथ आता है। यदि इन स्तंभों में UNIQUE बाधा नहीं है, तो यह संभव है कि कई पंक्तियाँ ऊपरी स्थिति से मेल खा सकती हैं। इस मामले में, कोई अपरर्ट नहीं किया जाना चाहिए क्योंकि यह अस्पष्ट है कि किस रिकॉर्ड को अपडेट किया जाना चाहिए। पांडा से इसे लागू करने के लिए, प्रत्येक पंक्ति को व्यक्तिगत रूप से मूल्यांकन करने की आवश्यकता होगी ताकि यह जांचा जा सके कि केवल 1 या 0 पंक्तियां डालने से पहले मेल खाती हैं। हालांकि यह कार्यक्षमता लागू करने के लिए यथोचित रूप से सरल है, इसके परिणामस्वरूप प्रत्येक रिकॉर्ड को पढ़ने और लिखने के संचालन की आवश्यकता होती है (साथ ही अगर 1 रिकॉर्ड क्लैश पाया जाता है तो डिलीट), जो बड़े डेटासेट के लिए अत्यधिक अक्षम लगता है।
• भविष्य के सुधार में, यदि समुदाय इसके लिए कहता है, तो हम न केवल प्राथमिक कुंजी पर काम करने के लिए, बल्कि उपयोगकर्ता निर्दिष्ट क्षेत्रों पर भी काम करने के लिए अप्सर्ट का विस्तार करने के लिए कार्यक्षमता जोड़ सकते हैं। कोर-देव टीम के लिए यह एक दीर्घकालिक प्रश्न है, कि क्या पंडों को उन उपयोगकर्ताओं की सुरक्षा के लिए सरल रहना चाहिए जिनके पास खराब डिज़ाइन किया गया डेटाबेस है, या अधिक कार्यात्मकताएं हैं।

@TomAugspurger, अगर upsert प्रस्ताव सूट आप @cvonsteg के साथ बनाया गया है, हम कोड में कार्यान्वयन (incl। परीक्षण) के साथ आगे बढ़ना और एक पुल अनुरोध को बढ़ा देंगे।

अगर आप अलग तरीके से आगे बढ़ना चाहते हैं तो हमें बताएं।

प्रस्ताव के माध्यम से पढ़ना मेरी टूडू सूची में है। मैं अपने पर थोड़ा पीछे हूँ
अभी ईमेल करें।

बुधवार, 9 अक्टूबर, 2019 को सुबह 9:18 बजे रोमेन नोटिफिकेशन @github.com ने लिखा:

@TomAugspurger https://github.com/TomAugspurger , अगर डिजाइन हम
@cvonsteg https://github.com/cvonsteg के साथ डिज़ाइन किया गया आप पर सूट करता है, हम करेंगे
कोड में कार्यान्वयन के साथ आगे बढ़ें (परीक्षण सहित) और एक पुल बढ़ाएं
प्रार्थना।

अगर आप अलग तरीके से आगे बढ़ना चाहते हैं तो हमें बताएं।

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपका उल्लेख किया गया था।
इस ईमेल का सीधे उत्तर दें, इसे GitHub पर देखें
https://github.com/pandas-dev/pandas/issues/14553?email_source=notifications&email_token=AAKAOITBNTWOQRBW3OWDEZDQNXR25A5CNFSM4CU2M7O2YY3PNVWWK3TUL52HS4DFVREXGEA43VMVBW63LNMVW-5K2K7LNMVWXH
या थ्रेड को म्यूट करें
https://github.com/notifications/unsubscribe-auth/AAKAOIRZQEQWUY36PQ36QTLQNXR25ANCNFSM4CU2M7OQ
.

मेरे पास व्यक्तिगत रूप से इसके खिलाफ कुछ भी नहीं है इसलिए लगता है कि एक पीआर का स्वागत है। SQLAlchemy कोर का उपयोग करते हुए सभी DBMs में एक कार्यान्वयन निश्चित रूप से यह कैसे शुरू होना चाहिए यदि मैं आपके बिंदुओं को सही ढंग से पढ़ रहा हूं, और केवल प्राथमिक कुंजी के साथ।

छोटे और केंद्रित शुरुआत करना और वहां से विस्तार करना हमेशा आसान होता है

इस सुविधा की सख्त जरूरत है।

पीआर हमने cvonsteg के साथ लिखा था अब कार्यक्षमता देना चाहिए: अब समीक्षा के लिए नीचे!

यह कार्यक्षमता बिल्कुल शानदार होगी! मैं जीथब की शब्दावली में बहुत पारंगत नहीं हूँ; क्या @ Rugg2 द्वारा टिप्पणी की गई है कि कार्यक्षमता "अब समीक्षा के लिए नीचे है" का अर्थ है कि यह पांडा टीम की समीक्षा करने के लिए नीचे है? और अगर यह स्वीकृत है, तो क्या इसका मतलब यह है कि यह पांडा के एक नए संस्करण के माध्यम से उपलब्ध हो जाएगा जिसे हम स्थापित कर सकते हैं, या क्या हमें गिट के माध्यम से मैन्युअल रूप से प्रतिबद्धता लागू करने की आवश्यकता होगी? (मुझे इसके साथ कोंडा के माध्यम से समस्याएं आई हैं, इसलिए यदि ऐसा है तो मैं इस कार्यक्षमता के तैयार होने तक गति प्राप्त करना चाहता हूं)। शुक्रिया!!

@ pmgh2345 - हाँ, जैसा कि आपने कहा, "अब समीक्षा के लिए नीचे" का अर्थ है कि एक पुल अनुरोध उठाया गया है और मूल देवों की समीक्षा के अधीन है। आप ऊपर उल्लिखित पीआर (#29636) देख सकते हैं। एक बार यह स्वीकृत हो जाने के बाद, आप तकनीकी रूप से अद्यतन कोड के साथ शाखा को फोर्क कर सकते हैं और पांडा के अपने स्थानीय संस्करण को अंतर्निहित कार्यक्षमता के साथ संकलित कर सकते हैं। हालांकि, मैं व्यक्तिगत रूप से प्रतीक्षा करने की अनुशंसा करता हूं जब तक कि इसे मास्टर में विलय नहीं किया जाता है और जारी किया जाता है, और फिर बस पाइप स्थापित करना पांडा का नवीनतम संस्करण।

पीआर हमने cvonsteg के साथ लिखा था अब कार्यक्षमता देना चाहिए: अब समीक्षा के लिए नीचे!

if_exists का उपयोग करने के बजाय to_sql विधि में एक नया पैरामीटर जोड़ना उचित हो सकता है। कारण, if_exists तालिका की जांच कर रहा है, पंक्ति नहीं, अस्तित्व।

@cvonsteg मूल रूप से method= का उपयोग करके प्रस्तावित किया गया था , जो if_exists दो अर्थ होने की अस्पष्टता से बच जाएगा।

df.to_sql(
    name='table_name', 
    con=engine, 
    if_exists='append', 
    method='upsert_update' # (or upsert_ignore)
)

@brylie हम एक नया पैरामीटर जोड़ सकते हैं जो सच है, लेकिन जैसा कि आप जानते हैं कि प्रत्येक नया पैरामीटर एक एपीआई को और अधिक

यदि हमें वर्तमान मापदंडों में से एक को चुनना है, जैसा कि आपने कहा था कि हमने शुरू में method तर्क का उपयोग करने के बारे में सोचा था, लेकिन अधिक विचारों के बाद हमने महसूस किया कि दोनों (1) उपयोग और (2) तर्क बेहतर रूप से if_exists तर्क।

1) एपीआई उपयोग के दृष्टिकोण से
उपयोगकर्ता एक तरफ विधि = "बहु" या कोई नहीं, और दूसरी तरफ "अप्सर्ट" दोनों को चुनना चाहेगा। हालांकि, "अप्सर्ट" कार्यक्षमता का उपयोग करने के साथ समान रूप से मजबूत उपयोग के मामले नहीं हैं जैसे कि if_exists="append" या "replace", यदि कोई हो।

2) तर्क की दृष्टि से

• विधि वर्तमान में _how_ पर काम करती है, डेटा डाला जा रहा है: पंक्ति से पंक्ति या "बहु"
• if_exists हम अपने रिकॉर्ड को कैसे प्रबंधित करते हैं, इसके व्यावसायिक तर्क को कैप्चर करता है: "प्रतिस्थापित करें", "संलग्न करें", "अपसर्ट_अपडेट" (कुंजी मौजूद होने पर अप्सर्ट करें, नया होने पर संलग्न करें), "अप्सर्ट_इग्नोर" (कुंजी मौजूद होने पर अनदेखा करें, नया होने पर संलग्न करें)। हालांकि रिप्लेस और एपेंड टेबल के अस्तित्व को देख रहे हैं, इसे रिकॉर्ड स्तर पर इसके प्रभाव से भी समझा जा सकता है।

मुझे बताएं कि क्या मैं आपकी बात को अच्छी तरह से समझता हूं, और कृपया चिल्लाएं यदि आपको लगता है कि समीक्षा के तहत वर्तमान कार्यान्वयन (पीआर # 29636) शुद्ध नकारात्मक होगा!

हाँ, आप मेरी बात समझते हैं। वर्तमान कार्यान्वयन एक शुद्ध सकारात्मक है लेकिन अस्पष्ट शब्दार्थ से थोड़ा कम है।

मैं अभी भी यह मानता हूं कि if_exists केवल एक चीज, टेबल अस्तित्व को संदर्भित करना जारी रखना चाहिए। मापदंडों में अस्पष्टता होने से पठनीयता पर नकारात्मक प्रभाव पड़ता है, और जटिल आंतरिक तर्क हो सकता है। जबकि, एक नया पैरामीटर जोड़ना, जैसे upsert=True स्पष्ट और स्पष्ट है।

नमस्कार!

यदि आप अप्सर्ट करने के लिए एक गैर अज्ञेय कार्यान्वयन देखना चाहते हैं तो मेरे पास मेरी लाइब्रेरी पैंग्रेस के साथ एक उदाहरण है। यह उन डेटाबेस प्रकारों के लिए विशिष्ट sqlalchemy फ़ंक्शंस का उपयोग करके PostgreSQL और MySQL को संभालता है। SQlite के लिए (और अन्य डेटाबेस प्रकार एक समान अपरर्ट सिंटैक्स की अनुमति देते हैं) यह एक संकलित नियमित sqlalchemy सम्मिलित करें का उपयोग करता है।

मैं इस सोच को साझा करता हूं कि यह सहयोगियों को कुछ विचार दे सकता है (हालांकि मुझे पता है कि हम चाहते हैं कि यह SQL प्रकार अज्ञेयवादी हो जो बहुत समझ में आता है)। इसके अलावा शायद गति की तुलना भी दिलचस्प होगी जब @cvonsteg का पीआर गुजरता है।
कृपया ध्यान दें कि मैं लंबे समय से sqlalchemy विशेषज्ञ या ऐसा नहीं हूं!

मैं वास्तव में यह सुविधा चाहता हूं। मैं सहमत हूं कि method='upsert_update' एक अच्छा विचार है।

क्या यह अभी भी योजनाबद्ध है? पंडों को वास्तव में इस सुविधा की आवश्यकता है

हाँ यह अभी भी योजनाबद्ध है, और हम लगभग वहाँ हैं!

कोड लिखा है, लेकिन एक परीक्षा है जो पास नहीं होती है। मदद का स्वागत किया!
https://github.com/pandas-dev/pandas/pull/29636

मंगलवार, 5 मई, 2020, 19:18 को लियोनेल एटेंसियो नोटिफिकेशन @github.com ने लिखा:

क्या यह अभी भी योजनाबद्ध है? पंडों को वास्तव में इस सुविधा की आवश्यकता है

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

नमस्कार! क्या कार्यक्षमता तैयार है या कुछ अभी भी गायब है? अगर अभी भी कुछ छूट गया है, तो कृपया मुझे बताएं कि क्या मैं कुछ मदद कर सकता हूं!

कोई खबर?))

जावा दुनिया से आ रहा है, कभी नहीं सोचा था कि यह सरल कार्यक्षमता मेरे कोडबेस को उल्टा कर सकती है।

हेलो सब लोग,

मैंने देखा है कि एसक्यूएल में बोलियों में अप्सर्ट कैसे लागू किए जाते हैं और कई तकनीकें मिलती हैं जो यहां डिजाइन निर्णयों को सूचित कर सकती हैं। लेकिन पहले, मैं DELETE ... INSERT तर्क का उपयोग करने के खिलाफ चेतावनी देना चाहता हूं। यदि विदेशी कुंजी या ट्रिगर हैं, तो डेटाबेस में अन्य रिकॉर्ड नष्ट हो जाएंगे या अन्यथा गड़बड़ हो जाएंगे। MySQL में, REPLACE वही नुकसान करता है। मैंने वास्तव में डेटा को ठीक करने के लिए घंटों काम किया है क्योंकि मैंने REPLACE का उपयोग किया है। तो, उसने कहा, यहाँ SQL में लागू की गई तकनीकें हैं:

बोली | तकनीक
-- | --
माईएसक्यूएल | सम्मिलित करें ... डुप्लीकेट कुंजी अद्यतन पर
पोस्टग्रेएसक्यूएल | सम्मिलित करें ... संघर्ष पर
SQLite | सम्मिलित करें ... संघर्ष पर
डीबी2 | मर्ज
एसक्यूएल सर्वर | मर्ज
ओरेकल | मर्ज
एसक्यूएल:2016 | मर्ज

बेतहाशा भिन्न वाक्य रचना के साथ, मैं कार्यान्वयन बोली को अज्ञेयवादी बनाने के लिए DELETE ... INSERT का उपयोग करने के प्रलोभन को समझता हूं। लेकिन एक और तरीका है: हम एक अस्थायी तालिका और बुनियादी INSERT और UPDATE स्टेटमेंट का उपयोग करके MERGE स्टेटमेंट के तर्क का अनुकरण कर सकते हैं। SQL:2016 MERGE सिंटैक्स इस प्रकार है:

MERGE INTO target_table 
USING source_table 
ON search_condition
    WHEN MATCHED THEN
        UPDATE SET col1 = value1, col2 = value2,...
    WHEN NOT MATCHED THEN
        INSERT (col1,col2,...)
        VALUES (value1,value2,...);

Oracle ट्यूटोरियल से उधार लिया गया
और SQL विकिबूक के अनुरूप समायोजित किया गया

चूंकि SQLAlchemy द्वारा समर्थित प्रत्येक बोली अस्थायी तालिकाओं का समर्थन करती है, इसलिए एक अप्सर्ट करने के लिए एक सुरक्षित, बोली-अज्ञेयवादी दृष्टिकोण एक ही लेनदेन में होगा:

1. एक अस्थायी तालिका बनाएँ।
2. उस अस्थायी तालिका में डेटा डालें।
3. एक अद्यतन करें ... शामिल हों।
4. INSERT जहां कुंजी (प्राथमिक या अद्वितीय) मेल नहीं खाती।
5. अस्थायी तालिका गिराओ।

एक बोली-अज्ञेय तकनीक होने के अलावा, इसका अंतिम उपयोगकर्ता को यह चुनने की अनुमति देकर विस्तारित होने का लाभ भी है कि डेटा कैसे डालें या कैसे अपडेट करें और साथ ही डेटा में शामिल होने के लिए कौन सी कुंजी है।

जबकि अस्थायी तालिकाओं का सिंटैक्स, और अपडेट जॉइन बोलियों के बीच थोड़ा भिन्न हो सकता है, उन्हें हर जगह समर्थित होना चाहिए।

MySQL के लिए मैंने जो अवधारणा लिखी है उसका प्रमाण नीचे दिया गया है:

import uuid

import pandas as pd
from sqlalchemy import create_engine


# This proof of concept uses this sample database
# https://downloads.mysql.com/docs/world.sql.zip


# Arbitrary, unique temp table name to avoid possible collision
source = str(uuid.uuid4()).split('-')[-1]

# Table we're doing our upsert against
target = 'countrylanguage'

db_url = 'mysql://<{user: }>:<{passwd: }>.@<{host: }>/<{db: }>'

df = pd.read_sql(
    f'SELECT * FROM `{target}`;',
    db_url
)

# Change for UPDATE, 5.3->5.4
df.at[0,'Percentage'] = 5.4
# Change for INSERT
df = df.append(
    {'CountryCode': 'ABW','Language': 'Arabic','IsOfficial': 'F','Percentage':0.0},
    ignore_index=True
)

# List of PRIMARY or UNIQUE keys
key = ['CountryCode','Language']

# Do all of this in a single transaction
engine = create_engine(db_url)
with engine.begin() as con:
    # Create temp table like target table to stage data for upsert
    con.execute(f'CREATE TEMPORARY TABLE `{source}` LIKE `{target}`;')
    # Insert dataframe into temp table
    df.to_sql(source,con,if_exists='append',index=False,method='multi')
    # INSERT where the key doesn't match (new rows)
    con.execute(f'''
        INSERT INTO `{target}`
        SELECT
            *
        FROM
            `{source}`
        WHERE
            (`{'`, `'.join(key)}`) NOT IN (SELECT `{'`, `'.join(key)}` FROM `{target}`);
    ''')
    # Create a doubled list of tuples of non-key columns to template the update statement
    non_key_columns = [(i,i) for i in df.columns if i not in key]
    # Whitespace for aesthetics
    whitespace = '\n\t\t\t'
    # Do an UPDATE ... JOIN to set all non-key columns of target to equal source
    con.execute(f'''
        UPDATE
            `{target}` `t`
                JOIN
            `{source}` `s` ON `t`.`{"` AND `t`.`".join(["`=`s`.`".join(i) for i in zip(key,key)])}`
        SET
            `t`.`{f"`,{whitespace}`t`.`".join(["`=`s`.`".join(i) for i in non_key_columns])}`;
    ''')
    # Drop our temp table.
    con.execute(f'DROP TABLE `{source}`;')

यहाँ, मैं निम्नलिखित धारणाएँ बनाता हूँ:

1. आपके स्रोत और गंतव्य की संरचना समान है।
2. कि आप अपने डेटाफ्रेम में डेटा का उपयोग करके सरल प्रविष्टियां करना चाहते हैं।
3. कि आप अपने डेटाफ़्रेम के डेटा के साथ सभी गैर-कुंजी स्तंभों को बस अपडेट करना चाहते हैं।
4. कि आप मुख्य कॉलम में डेटा में कोई परिवर्तन नहीं करना चाहते हैं।

मान्यताओं के बावजूद, मुझे आशा है कि मेरी मर्ज-प्रेरित तकनीक एक लचीला, मजबूत अप्सर्ट विकल्प बनाने के प्रयासों को सूचित करती है।

मुझे लगता है कि यह एक उपयोगी कार्यक्षमता है, हालांकि ऐसा लगता है कि किसी तालिका में पंक्तियों को जोड़ते समय इस तरह की एक सामान्य विशेषता होना सहज है।

कृपया इस फ़ंक्शन को जोड़ने के लिए फिर से सोचें: मौजूदा तालिका में पंक्तियों को जोड़ना बहुत उपयोगी है।
अलास पैंग्रेस पायथन 3.7+ तक सीमित है। जैसा कि मेरे मामले में (मुझे पुराने पायथन 3.4 का उपयोग करने के लिए मजबूर किया गया है) यह हमेशा एक व्यवहार्य समाधान नहीं होता है।

धन्यवाद, @GoldstHa - यह वास्तव में सहायक इनपुट है। मैं MERGE जैसे कार्यान्वयन के लिए POC बनाने का प्रयास करूंगा

DELETE/INSERT दृष्टिकोण के साथ मुद्दों को देखते हुए, और MySQL DBs पर @GoldstHa MERGE दृष्टिकोण पर संभावित अवरोधक, मैंने थोड़ा और खुदाई की है। मैंने sqlalchemy अद्यतन कार्यक्षमता का उपयोग करके अवधारणा के प्रमाण को एक साथ

संशोधित दृष्टिकोण प्रस्ताव

एपीआई के आसपास कुछ अच्छी चर्चाएं हुई हैं, और एक अप्सर्ट को वास्तव में कैसे कहा जाना चाहिए (यानी if_exists तर्क के माध्यम से, या एक स्पष्ट upsert तर्क के माध्यम से)। यह जल्द ही स्पष्ट किया जाएगा। अभी के लिए, SqlAlchemy upsert स्टेटमेंट का उपयोग करके कार्यक्षमता कैसे काम करेगी, इसके लिए यह छद्म कोड प्रस्ताव है:

Identify primary key(s) and existing pkey values from DB table (if no primary key constraints identified, but upsert is called, return an error)

Make a temp copy of the incoming DataFrame

Identify records in incoming DataFrame with matching primary keys

Split temp DataFrame into records which have a primary key match, and records which don't

if upsert:
    Update the DB table using `update` for only the rows which match
else:
    Ignore rows from DataFrame with matching primary key values
finally:
    Append remaining DataFrame rows with non-matching values in the primary key column to the DB table