Pandas: `.to_sql`に（キーが存在する場合は挿入または更新）オプションを追加します

これは素晴らしい機能ですが、主な問題は、パンダ自体に含めるために、データベースフレーバーに依存せず、sqlalchemyコア（sqlalchemy ORMではない）に基づいていることです。
これはこれを実装するのを難しくします..

ええ、アップサートはすべてのデータベースエンジンでサポートされているわけではないので、これはパンダの範囲外だと思います。

INSERT OR UPDATEはすべてのエンジンでサポートされているわけではありませんが、 INSERT OR REPLACEは、DataFrameインデックスの主キーのセットのターゲットテーブルから行を削除してから、 DataFrameのすべての行。 トランザクションでこれを実行する必要があります。

@TomAugspurgerサポートされているdbエンジンに

これも見たいです。 私は純粋なSQLとSQLAlchemyの使用の中間にあります（これはまだ機能していません。これは、私がdictを渡す方法と関係があると思います）。 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')
)

そして純粋なSQL：

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このスニペットは、複合キーの場合は機能しない可能性があり、そのシナリオにも注意する必要があります。 私は同じことをする方法を見つけようとします

この更新の問題を解決する1つの方法は、sqlachemyのbulk_update_mappingsを使用すること

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

私は@neilfrndesに同意し

多分。 誰かがPRをした場合。 さらに検討すると、一部のデータベースがサポートしていないという原則に基づいて、これに反対しているとは思いません。 しかし、私はSQLコードにあまり精通していないので、最善のアプローチが何であるかわかりません。

1つの可能性は、このPRが導入された場合に呼び出し可能なmethodを使用して、アップサートの例をいくつか提供することです： https ：

（テストされていない）のように見えるpostgresの場合：

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についても同様のことができます。

postgresではexecute_valuesを使用しています。 私の場合、クエリはjinja2テンプレートであり、更新セットを、何も実行しないかを示し

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お願いします、これがどのように機能するかの例を示してください。

私はbulk_update_mappingsを調べようとしましたが、本当に迷子になり、機能させることができませんでした。

@ cristianionescu92例は次のようになります：
次のフィールドを持つUserというテーブルがあります：idとname。

| id | 名前|
| --- | --- |
| 0 | ジョン|
| 1 | ジョー|
| 2 | ハリー|

同じ列で値が更新されたパンダのデータフレームがあります。

| id | 名前|
| --- | --- |
| 0 | クリス|
| 1 | ジェームズ|

また、データベースにアクセスするために開いているセッション変数があると仮定しましょう。 このメソッドを呼び出すことにより：

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

パンダはテーブルを辞書のリスト[{id：0、name： "chris"}、{id：1、name： "james"}]に変換し、SQLがテーブルの行を更新するために使用します。 したがって、最終的なテーブルは次のようになります。

| id | 名前|
| --- | --- |
| 0 | クリス|
| 1 | ジェームズ|
| 2 | ハリー|

こんにちは、 @ danich1 。ご回答ありがとう

私がしていることをお見せしましょう：

`pypyodbcをインポートします
from to_sql_newrows import clean_df_db_dups、to_sql_newrows＃これらはGitHubで見つけた2つの関数ですが、残念ながらリンクを思い出せません。 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はその1つです。特に、回避策は代わりにreplaceを使用することであるため、テーブルが削除され、すべてのビューと制約が削除されます。

私がより経験豊富なユーザーに見た代替案は、この段階でパンダの使用を停止することです。これは上流に伝播する傾向があり、パンダパッケージを経験豊富なユーザーの間で緩く保持します。 これはパンダが行きたい方向ですか？

to_sqlを可能な限りデータベースに依存せず、コアSQLアルケミーを使用することを理解しています。 ただし、真のアップサートの代わりに切り捨てまたは削除する方法でも、多くの価値が追加されます。

Pandas製品ビジョンとの統合
上記の議論の多くは、 method引数（ @kjfordがpsql_insert_copy言及）が導入され、呼び出し可能オブジェクトを渡す可能性が導入される前に発生しました。

私はパンダのコア機能に喜んで貢献するか、それができない場合は、以下のようなパンダ内でアップサート機能を実現する方法に関するソリューション/ベストプラクティスに関するドキュメントを提供します。
https://pandas.pydata.org/pandas-docs/stable/user_guide/io.html#io -sql-method

Pandasのコア開発/製品マネージャーにとって好ましい前進方法は何ですか？

私たちは、エンジン固有の実装を受け入れていると思います。 method='upsert'を使用するという提案は妥当なようですが、現時点では、明確な設計提案を考え出す人が必要だと思います。

MySQLテーブルの既存のデータを複数のCSVから時間の経過とともに更新したいという同様の要件があります。

df.to_sql（）を使用して、新しく作成した一時テーブルに新しいデータを挿入し、MySQLクエリを実行して、既存のテーブルのデータを追加/更新する方法を制御できると思いました。

MySQLリファレンス： https ：//stackoverflow.com/questions/2472229/insert-into-select-from-on-duplicate-key-update = active＃tab -top

免責事項：私はほんの数日前にPythonとPandasを使い始めました。

ちょっとパンダの人々：私はこれと同じ問題を抱えていて、パンダで最終的にロードして操作するレコードでローカルデータベースを頻繁に更新する必要がありました。 これを行うために単純なライブラリを作成しました。これは基本的に、デフォルトで主キーとしてDataFrameインデックスを使用するdf.to_sqlおよびpd.read_sql_tableの代用です。 sqlalchemyコアのみを使用します。

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

このツールはかなり意見が分かれており、Pandasにそのまま含めるのはおそらく適切ではありません。 しかし、私の特定のユースケースでは、問題は解決します...パンダに収まるようにこれをマッサージすることに興味がある場合は、喜んでお手伝いします。

今のところ、次のように機能します（現在のパンダとsqlalchemyの限られたケースでは、インデックスを主キーとして指定し、SQLiteまたはPostgresバックエンド、およびサポートされているデータ型）。

pip install pandabase / pandabase.to_sql（df、table_name、con_string、how = 'upsert'）

cvonstegを使用してこれに対する一般的な解決策に取り組んでいます。 10月に提案されたデザインで戻ってくることを計画しています。

@ rugg2、提案と私はのために以下の設計案が出ているよう@TomAugspurger upsertでオプションto_sql() 。

インターフェース提案

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クラスは、 SQLTable.insert（）メソッドから呼び出されるアップサートロジックを含む2つの新しいプライベートメソッドを受け取ります。

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コアを使用してエンジンに依存しない

• 一部のDBMSのみがupsertネイティブにサポートしており、実装はフレーバーによって異なる可能性があります
• 最初の実装として、すべてのデータベース管理システムにわたって1つの実装をテストおよび保守する方が簡単であると考えています。 将来的には、需要があれば、エンジン固有の実装を追加できます。
• upsert_ignoreこれらの操作は一致するレコードでは明らかにスキップされます
• パフォーマンスの観点から、エンジンに依存しない実装とエンジン固有の実装を比較する価値があります。

（2）主キーのみのアップサート

• 特に指定がない限り、アップサートはデフォルトで主キーの衝突になります
• 一部のDBMSでは、ユーザーが非主キー列を指定して、一意性をチェックすることができます。 これによりユーザーはより柔軟になりますが、潜在的な落とし穴があります。 これらの列にUNIQUE制約がない場合は、複数の行がアップサート条件に一致する可能性があります。 この場合、どのレコードを更新する必要があるかがあいまいであるため、アップサートを実行しないでください。 パンダからこれを実施するには、挿入する前に、各行を個別に評価して、1行または0行のみが一致することを確認する必要があります。 この機能の実装はかなり簡単ですが、各レコードで読み取りおよび書き込み操作（さらに、1つのレコードの衝突が見つかった場合は削除）が必要になり、大規模なデータセットでは非常に非効率的です。
• 将来の改善では、コミュニティがそれを要求した場合、主キーだけでなくユーザー指定のフィールドでも機能するようにアップサートを拡張する機能を追加することができます。 これは、コア開発チームにとって長期的な質問です。データベースの設計が不十分なユーザーを保護するために、またはより多くの機能を備えたユーザーを保護するために、パンダをシンプルに保つ必要があるかどうかについてです。

@ TomAugspurger 、 upsert提案が適切な場合は、コード（テストを含む）での実装を続行し、プルリクエストを生成します。

別の方法で進めたい場合はお知らせください。

提案を読むことは私のやることリストにあります。 私は少し遅れています
今すぐメールしてください。

水、2019年10月9日には午前9時18分で、AMロマンの[email protected]は書きました：

@TomAugspurger https://github.com/TomAugspurger 、デザインが
@cvonsteg https://github.com/cvonstegで設計されたものがあなたに合っています、私たちは
コード（テストを含む）で実装を進め、プルを上げます
リクエスト。

別の方法で進めたい場合はお知らせください。

—
あなたが言及されたのであなたはこれを受け取っています。
このメールに直接返信し、GitHubで表示してください
https://github.com/pandas-dev/pandas/issues/14553?email_source=notifications&email_token=AAKAOITBNTWOQRBW3OWDEZDQNXR25A5CNFSM4CU2M7O2YY3PNVWWK3TUL52HS4DFVREXG43VMVBW63LNMVXHJKTDN
またはスレッドをミュートします
https://github.com/notifications/unsubscribe-auth/AAKAOIRZQEQWUY36PQ36QTLQNXR25ANCNFSM4CU2M7OQ
。

個人的には反対はないので、PRは大歓迎だと思います。 SQLAlchemyコアを使用するすべてのDBMにわたる1つの実装は、ポイントを正しく読み取っている場合にこれをどのように開始するかであり、主キーだけでも同じです。

小さく始めて集中し、そこから拡大するのは常に簡単です

この機能がひどく必要です。

cvonstegで書いたPRは、機能を提供するはずです：今すぐレビューまで！

この機能は絶対に素晴らしいでしょう！ 私はgithubの語彙にあまり精通していません。 機能が「今すぐレビューする」という@ rugg2のコメントは、それをレビューするのはパンダチーム

@ pmgh2345-うん、あなたが言ったように、「今すぐレビューする」とは、プルリクエストが発生し、コア開発者からレビュー中であることを意味します。 上記のPR（＃29636）をご覧いただけます。 承認されたら、更新されたコードでブランチを技術的にフォークし、機能が組み込まれた独自のローカルバージョンのパンダをコンパイルできます。ただし、マスターにマージされてリリースされるまで待ってから、ピップインストールすることをお勧めします。パンダの最新バージョン。

cvonstegで書いたPRは、機能を提供するはずです：今すぐレビューまで！

if_existsを使用するのではなく、 to_sqlメソッドに新しいパラメータを追加する価値があるかもしれません。 その理由は、 if_existsは行ではなく、テーブルの存在をチェックしているからです。

@cvonstegは当初、 method=を使用することを提案しました。これにより、 if_existsに対して2つの意味を持つというあいまいさが回避されます。

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

@brylie真の新しいパラメーターを追加することもできますが、ご存知のように、新しいパラメーターごとにAPIが不格好になります。 トレードオフがあります。

あなたが言ったように、現在のパラメータから選択する必要がある場合、最初はmethod引数を使用することを考えましたが、さらに検討した後、（1）使用法と（2）ロジックの両方がif_existsよく適合することに気付きました

1）APIの使用の観点から
ユーザーは、一方でmethod = "multi"またはNoneを選択し、他方で "upsert"を選択することをお勧めします。 ただし、「upsert」機能をif_exists = "append"または "replace"と同時に使用する場合、同等の強力なユースケースはありません。

2）論理的な観点から

• メソッドは現在、データが挿入されている_how_で機能します：行ごとまたは「マルチ」
• if_existsは、レコードの管理方法のビジネスロジックをキャプチャします。 replaceとappendはテーブルの存在を調べていますが、レコードレベルでの影響からも理解できます。

私があなたのポイントをよく理解したかどうか私に知らせてください、そしてあなたがレビュー中の現在の実装（PR＃29636）が正味のネガティブになると思うなら叫んでください！

うん、あなたは私のポイントを理解しています。 現在の実装は正味のポジティブですが、あいまいなセマンティクスによってわずかに減少しています。

if_existsは、テーブルの存在という1つのことだけを参照し続ける必要があると私は今でも主張しています。 パラメータがあいまいになると、読みやすさに悪影響を及ぼし、複雑な内部ロジックにつながる可能性があります。 一方、 upsert=Trueような新しいパラメータを追加することは、明確で明示的です。

こんにちは！

アップサートを実行するための不可知論的でない実装を見たい場合は、ライブラリpangresを使用した例があります。 これらのデータベースタイプに固有のsqlalchemy関数を使用してPostgreSQLとMySQLを処理します。 SQlite（および同様のアップサート構文を可能にする他のデータベースタイプ）に関しては、コンパイルされた通常のsqlalchemyInsertを使用します。

私は、これが共同作業者にいくつかのアイデアを与えるかもしれないという考えを共有します（ただし、これをSQL型にとらわれず、非常に理にかなっていることを認識しています）。 また、 @ cvonstegのPRが完了すると、速度の比較も興味深いでしょう。
私は長い間sqlalchemyの専門家などではないことに注意してください！

私は本当にこの機能が欲しいです。 method='upsert_update'が良い考えであることに同意します。

これはまだ計画されていますか？ パンダは本当にこの機能が必要です

はい、これはまだ計画されており、もうすぐです！

コードは書かれていますが、合格しないテストが1つあります。 ようこそ！
https://github.com/pandas-dev/pandas/pull/29636

火、2020年5月5日には、19時18分レオネルAtencioの[email protected]は書きました：

これはまだ計画されていますか？ パンダは本当にこの機能が必要です

—
あなたが言及されたのであなたはこれを受け取っています。
このメールに直接返信し、GitHubで表示してください
https://github.com/pandas-dev/pandas/issues/14553#issuecomment-624223231 、
または購読を解除する
https://github.com/notifications/unsubscribe-auth/AI5X625A742YTYFZE7YW5A3RQBJ6NANCNFSM4CU2M7OQ
。

こんにちは！ 機能の準備はできていますか、それともまだ何かが足りませんか？ それでも足りないものがある場合は、何かお手伝いできることがあればお知らせください。

連絡あった？））

Javaの世界から来たので、この単純な機能が私のコードベースをひっくり返すかもしれないとは思ってもみませんでした。

皆さんこんにちは、

方言全体でSQLにアップサートがどのように実装されているかを調べたところ、ここで設計上の決定に役立ついくつかの手法が見つかりました。 ただし、最初に、DELETE ... INSERTロジックを使用しないように警告したいと思います。 外部キーまたはトリガーがある場合、データベース全体の他のレコードが削除されるか、そうでなければ混乱することになります。 MySQLでは、REPLACEは同じダメージを与えます。 REPLACEを使用したので、実際にデータを修正するために何時間もの作業を作成しました。 つまり、SQLで実装されている手法は次のとおりです。

方言| 技術
-| -
MySQL | INSERT ... ON DUPLICATE KEY UPDATE
PostgreSQL | 挿入...競合について
SQLite | 挿入...競合について
Db2 | マージ
SQL Server | マージ
オラクル| マージ
SQL：2016 | マージ

構文は大きく異なりますが、DELETE ... INSERTを使用して実装方言にとらわれないようにしたいという誘惑を理解しています。 ただし、別の方法があります。一時テーブルと基本的なINSERTおよびUPDATEステートメントを使用して、MERGEステートメントのロジックを模倣できます。 SQL： 2016MERGE構文は次のとおりです。

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. キー（PRIMARYまたはUNIQUE）が一致しない場合に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. キー列のデータに変更を加えたくないこと。

仮定にもかかわらず、私のMERGEに着想を得た手法が、柔軟で堅牢なアップサートオプションを構築するための取り組みに役立つことを願っています。

これは便利な機能だと思いますが、テーブルに行を追加するときにこのような一般的な機能を使用するのは直感的であるため、範囲外のようです。

この関数を追加することをもう一度考えてください。既存のテーブルに行を追加すると非常に便利です。
AlasPangresはPython3.7以降に制限されています。 私の場合のように（私は古いPython 3.4を使用することを余儀なくされています）、それは常に実行可能な解決策ではありません。

ありがとう、 @ GoldstHa-それは本当に役立つ入力です。 MERGEのような実装のPOCを作成しようとします

DELETE/INSERTアプローチの問題と、 MySQLDBでの@GoldstHa MERGEアプローチの潜在的なブロッカーを考慮して、もう少し掘り下げました。 sqlalchemyの更新機能を使用して概念実証をまとめました。これは有望に見えます。 今週はPandasコードベースで適切に実装し、このアプローチがすべてのDBフレーバーで機能するようにします。

修正されたアプローチの提案

APIと、アップサートを実際に呼び出す方法（つまり、 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