Pandas: `.to_sql`에 (키가 있는 경우 삽입 또는 업데이트) 옵션 추가

이것은 좋은 기능이 될 것이지만 주요 문제는 pandas 자체에 포함하기 위해 데이터베이스 취향에 독립적이고 sqlalchemy 코어(sqlalchemy ORM이 아님)를 기반으로 하기를 원한다는 것입니다.
이것은 구현하기 어렵게 만들 것입니다 ..

예, upsert가 모든 db 엔진에서 지원되지 않기 때문에 이것이 팬더의 범위를 벗어났다고 생각합니다.

INSERT OR UPDATE 가 모든 엔진에서 지원되는 것은 아니지만 INSERT OR REPLACE 는 DataFrame 인덱스의 기본 키 집합에 대한 대상 테이블에서 행을 삭제한 다음 DataFrame의 모든 행. 트랜잭션에서 이것을 하고 싶을 것입니다.

@TomAugspurger 지원되는 db 엔진에 대해 upsert 옵션을 추가하고 지원되지 않는 db 엔진에 대해 오류를 발생시킬 수 있습니까?

이것도 보고 싶네요. 나는 순수한 SQL과 SQL Alchemy를 사용하는 사이에 끼어 있습니다. 나는 대량 삽입을 위해 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_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의 bulk_update_mappings 를 사용하는

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

@neilfrndes에 동의합니다. 일부 DB가 지원하지 않기 때문에 이와 같은 멋진 기능이 구현되지 않도록 해서는 안 됩니다. 이 기능이 발생할 가능성이 있습니까?

아마. 누군가가 PR을 한다면. 좀 더 생각해 보면 일부 데이터베이스가 지원하지 않는다는 원칙에 따라 이에 반대하지 않는다고 생각합니다. 그러나 나는 sql 코드에 너무 익숙하지 않으므로 최선의 접근 방식이 무엇인지 잘 모르겠습니다.

한 가지 가능성은 이 PR이 도입된 경우 method 호출 가능을 사용하여 upsert에 대한 몇 가지 예를 제공하는 것입니다: 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 이것이 어떻게 작동하는지 예를 들어 주시겠습니까?

나는 bulk_update_mappings를 살펴보려고 했지만 정말로 길을 잃어 작동하게 만들지 못했습니다.

@critianionescu92 예는 다음과 같습니다.
id 및 name 필드가 있는 User라는 테이블이 있습니다.

| 아이디 | 이름 |
| --- | --- |
| 0 | 존 |
| 1 | 조 |
| 2 | 해리 |

열은 같지만 값이 업데이트된 팬더 데이터 프레임이 있습니다.

| 아이디 | 이름 |
| --- | --- |
| 0 | 크리스 |
| 1 | 제임스 |

또한 데이터베이스에 액세스하기 위해 열려 있는 세션 변수가 있다고 가정해 보겠습니다. 이 메서드를 호출하여:

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

Pandas는 테이블을 sql이 테이블의 행을 업데이트하는 데 사용할 사전 목록 [{id: 0, name: "chris"}, {id: 1, name:"james"}]으로 변환합니다. 따라서 최종 테이블은 다음과 같습니다.

| 아이디 | 이름 |
| --- | --- |
| 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 는 그 중 하나입니다. 특히 많은 사람들이 해결 방법이 replace 대신 사용하여 테이블과 함께 모든 보기 및 제약 조건을 삭제한다는 사실을 알고 있기 때문입니다.

경험 많은 사용자에게서 본 대안은 이 단계에서 판다 사용을 중단하는 것입니다. 이것은 업스트림으로 전파되는 경향이 있고 경험 많은 사용자 사이에서 판다 패키지를 느슨하게 유지하게 만듭니다. 이것이 판다가 가고자 하는 방향인가?

나는 우리가 to_sql이 가능한 한 데이터베이스에 구애받지 않고 핵심 SQL 연금술을 사용하기를 원한다는 것을 이해합니다. 진정한 upsert 대신 자르거나 삭제하는 방법은 여전히 ​​많은 가치를 추가합니다.

Pandas 제품 비전과 통합
위의 많은 논쟁은 method 인수( @kjford 가 psql_insert_copy 로 언급한 바와 같이)가 도입 되고

나는 Pandas의 핵심 기능 또는 실패하는 경우 아래와 같이 Pandas 내에서 upsert 기능을 달성하는 방법에 대한 솔루션/모범 사례에 대한 문서에 기꺼이 기여하고 싶습니다.
https://pandas.pydata.org/pandas-docs/stable/user_guide/io.html#io -sql-method

Pandas 핵심 개발/제품 관리자가 선호하는 방향은 무엇입니까?

나는 우리가 엔진에 특정한 구현에 열려 있다고 생각합니다. method='upsert' 를 사용하자는 제안은 타당해 보이지만 현시점에서 명확한 디자인 제안을 해줄 누군가가 필요하다고 생각합니다.

시간이 지남에 따라 여러 CSV에서 MySQL 테이블의 기존 데이터를 업데이트하려는 유사한 요구 사항이 있습니다.

나는 df.to_sql()이 새로운 데이터를 새로 생성된 임시 테이블 에 삽입한 다음 MySQL 쿼리를 실행하여 기존 테이블에 데이터를 추가/업데이트하는 방법을 제어할 수 있다고 생각했습니다.

MySQL 참조: https://stackoverflow.com/questions/2472229/insert-into-select-from-on-duplicate-key-update?answertab=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에 있는 그대로 포함하기에 적합하지 않을 수 있습니다. 그러나 내 특정 사용 사례의 경우 문제를 해결합니다. Pandas에 맞게 마사지하는 데 관심이 있다면 기꺼이 도와드리겠습니다.

현재로서는 다음이 작동합니다(current-ish pandas 및 sqlalchemy의 제한된 경우, 기본 키로 명명된 index, SQLite 또는 Postgres 백엔드 및 지원되는 데이터 유형):

pip install pandabase / pandabase.to_sql(df, table_name, con_string, how='upsert')

cvonsteg를 사용하여 이에 대한 일반적인 솔루션을 작업 중입니다. 10월에 제안된 디자인으로 돌아올 계획입니다.

@TomAugspurger 가 제안한 대로 @rugg2 와 저는 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 클래스는 SQLTable.insert() 메소드에서 호출되는 upsert 논리를 포함하는 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 지원하며 구현은 버전에 따라 다를 수 있습니다.
• 첫 번째 구현으로서 우리는 모든 dbms에서 하나의 구현을 테스트하고 유지 관리하는 것이 더 쉬울 것이라고 믿습니다. 향후 수요가 있는 경우 엔진별 구현을 추가할 수 있습니다.
• upsert_ignore 이러한 작업은 일치하는 레코드에서 분명히 건너뜁니다.
• 성능 측면에서 엔진에 구애받지 않는 구현과 엔진에 특정한 구현을 비교할 가치가 있습니다.

(2) 기본 키에만 Upsert

• 달리 지정되지 않는 한 Upserts는 기본 키 충돌로 기본 설정됩니다.
• 일부 DBMS에서는 사용자가 기본 키가 아닌 열을 지정하여 고유성을 확인할 수 있습니다. 이것은 사용자에게 더 많은 유연성을 부여하지만 잠재적인 함정이 있습니다. 이러한 열에 UNIQUE 제약 조건이 없으면 여러 행이 upsert 조건과 일치할 수 있습니다. 이 경우 업데이트해야 하는 레코드가 모호하므로 upsert를 수행해서는 안 됩니다. pandas에서 이를 적용하려면 삽입하기 전에 각 행을 개별적으로 평가하여 1개 또는 0개 행만 일치하는지 확인해야 합니다. 이 기능은 구현하기가 상당히 간단하지만 각 레코드에 읽기 및 쓰기 작업(1개 레코드 충돌이 발견된 경우 삭제)이 필요하므로 더 큰 데이터 세트에서는 매우 비효율적입니다.
• 향후 개선 사항에서 커뮤니티에서 요청하는 경우 기본 키뿐만 아니라 사용자 지정 필드에서도 작동하도록 upsert를 확장하는 기능을 추가할 수 있습니다. 이것은 Pandas가 잘못 설계된 데이터베이스 또는 더 많은 기능을 가진 사용자를 보호하기 위해 단순하게 유지되어야 하는지에 대한 핵심 개발 팀의 장기적인 질문입니다.

@TomAugspurger , upsert 제안이 귀하에게 적합

다른 방식으로 진행하려면 알려주십시오.

제안서를 읽는 것은 나의 할 일 목록에 있습니다. 나는 내보다 약간 뒤쳐져있다.
지금 이메일.

2019년 10월 9일 수요일 오전 9:18 Romain [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=AAKAOITBNTWOQRBW3OWDEZDQNXR25A5CNFSM4CU2M7O2YY3PNVWWK3TUL52HS4DFVEXG43VMXVBW
또는 스레드 음소거
https://github.com/notifications/unsubscribe-auth/AAKAOIRZQEQWUY36PQ36QTLQNXR25ANCNFSM4CU2M7OQ
.

나는 개인적으로 그것에 대해 반대하는 것이 없으므로 PR을 환영한다고 생각합니다. SQLAlchemy 코어를 사용하는 모든 DBM에 대한 한 가지 구현은 내가 귀하의 요점을 올바르게 읽고 기본 키와 동일한 경우 확실히 시작해야 하는 방법입니다.

항상 작게 시작하여 집중하고 확장하기가 더 쉽습니다.

이 기능이 절실히 필요합니다.

우리가 cvonsteg로 작성한 PR은 이제 기능을 제공해야 합니다: 지금 리뷰로!

이 기능은 절대적으로 영광스러울 것입니다! 나는 github의 어휘에 정통하지 않습니다. 기능이 "지금 리뷰로 진행 중"이라는 @rugg2 의 의견은 해당 기능을 검토하는 것이 팬더 팀에 달려 있다는 의미인가요? 승인되면 설치할 수 있는 새 버전의 판다를 통해 사용할 수 있게 됩니까? 아니면 git을 통해 직접 커밋을 적용해야 합니까? (나는 conda를 통해 이것에 문제가 있었으므로 이 경우 이 기능이 준비될 때까지 속도를 높이고 싶습니다.) 감사합니다!!

@ pmgh2345 - 네, "지금 리뷰까지"는 풀 리퀘스트가 제기되었고 핵심 개발자로부터 검토

우리가 cvonsteg로 작성한 PR은 이제 기능을 제공해야 합니다: 지금 리뷰로!

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 사실인 새 매개변수를 추가할 수 있지만 알다시피 각각의 새 매개변수는 API를 더 투박하게 만듭니다. 절충안이 있습니다.

현재 매개변수 중에서 선택해야 하는 경우 처음에는 method 인수를 사용하려고 생각했지만 더 많은 생각을 한 후에 (1) 사용법과 (2) 논리가 모두 if_exists 더 적합하다는 것을 깨달았습니다.

1) API 사용 관점에서
사용자는 한편으로는 method="multi" 또는 None을 선택하고 다른 한편으로는 "upsert"를 선택하기를 원할 것입니다. 그러나 if_exists="append" 또는 "replace"(있는 경우)와 동시에 "upsert" 기능을 사용하는 것과 동일한 강력한 사용 사례는 없습니다.

2) 논리적인 관점에서

• 방법은 현재 데이터가 삽입되는 _how_에 대해 작동합니다: 행 단위 또는 "다중"
• if_exists 는 "replace", "append", "upsert_update"(키가 있는 경우 upsert, 새 경우 추가), "upsert_ignore"(키가 있는 경우 무시, 새 경우 추가)와 같이 레코드를 관리하는 방법에 대한 비즈니스 논리를 캡처합니다. 바꾸기와 추가는 테이블의 존재를 살펴보지만 레코드 수준에서의 영향으로도 이해할 수 있습니다.

귀하의 요점을 잘 이해했다면 알려주시고, 현재 검토 중인 구현(PR #29636)이 부정적인 영향을 미칠 것이라고 생각하시면 큰 소리로 말씀해 주십시오!

네, 제 요점을 이해하고 계십니다. 현재 구현은 순 긍정적이지만 모호한 의미로 인해 약간 감소했습니다.

나는 여전히 if_exists 가 테이블 존재라는 한 가지만 계속 참조해야 한다고 주장합니다. 매개변수에 모호성이 있으면 가독성에 부정적인 영향을 미치고 내부 논리가 복잡해질 수 있습니다. 반면 upsert=True 와 같은 새 매개변수를 추가하는 것은 명확하고 명시적입니다.

여보세요!

upserts 수행에 대한 불가지론적 구현을 ​​보려면 내 라이브러리

공동 작업자에게 몇 가지 아이디어를 제공할 수 있다는 생각을 공유합니다. 또한 @cvonsteg 의 PR 이 진행될 때 속도 비교도 흥미로울 것입니다.
저는 오랫동안 sqlalchemy 전문가가 아니었습니다!

이 기능을 정말 원합니다. method='upsert_update' 가 좋은 생각이라는 데 동의합니다.

이거 아직 예정인가요? 팬더는 이 기능이 정말 필요합니다

예, 이것은 아직 계획되어 있으며 거의 ​​다 왔습니다!

코드가 작성되었지만 통과하지 못한 테스트가 하나 있습니다. 도움을 환영합니다!
https://github.com/pandas-dev/pandas/pull/29636

2020년 5월 5일 화요일 19:18 Leonel Atencio [email protected]에서 다음과 같이 썼습니다.

이거 아직 예정인가요? 팬더는 이 기능이 정말 필요합니다

—
당신이 언급되었기 때문에 이것을 받는 것입니다.
이 이메일에 직접 답장하고 GitHub에서 확인하세요.
https://github.com/pandas-dev/pandas/issues/14553#issuecomment-624223231 ,
또는 구독 취소
https://github.com/notifications/unsubscribe-auth/AI5X625A742YTYFZE7YW5A3RQBJ6NANCNFSM4CU2M7OQ
.

여보세요! 기능이 준비되었거나 아직 누락된 것이 있습니까? 그래도 누락된 것이 있으면 도움이 필요하면 알려주세요!

소식이 있나요?))

Java 세계에서 왔기 때문에 이 간단한 기능이 내 코드베이스를 완전히 뒤집을 것이라고는 생각하지 못했습니다.

안녕하세요 여러분,

나는 upsert가 여러 방언에 걸쳐 SQL에서 구현되는 방법을 살펴보았고 여기에서 디자인 결정을 알릴 수 있는 여러 기술을 찾았습니다. 그러나 먼저 DELETE ... INSERT 논리 사용에 대해 경고하고 싶습니다. 외래 키나 트리거가 있는 경우 데이터베이스 전체의 다른 레코드가 삭제되거나 엉망이 됩니다. MySQL에서 REPLACE는 동일한 피해를 줍니다. REPLACE를 사용했기 때문에 실제로 데이터를 수정하는 데 몇 시간이나 걸렸습니다. 즉, SQL에서 구현된 기술은 다음과 같습니다.

방언 | 기술
-- | --
MySQL | INSERT ... 중복 키 업데이트 시
PostgreSQL | INSERT ... 충돌 시
SQLite | INSERT ... 충돌 시
DB2 | 병합
SQL 서버 | 병합
오라클 | 병합
SQL: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,...);

오라클 튜토리얼 에서 차용
SQL Wikibook 에 맞게 조정됨

SQLAlchemy에서 지원하는 모든 방언은 임시 테이블을 지원하므로 upsert를 수행하는 더 안전하고 방언에 구애받지 않는 접근 방식은 단일 트랜잭션에서 다음과 같습니다.

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에서 영감을 얻은 기술이 유연하고 강력한 upsert 옵션을 구축하려는 노력에 정보가 되기를 바랍니다.

나는 이것이 유용한 기능이라고 생각하지만 범위를 벗어나 테이블에 행을 추가하면서 이러한 공통 기능을 갖는 것이 직관적인 것처럼 보입니다.

이 기능을 추가하려면 다시 생각해 보십시오. 기존 테이블에 행을 추가하는 것은 매우 유용합니다.
Alas Pangres는 Python 3.7 이상으로 제한됩니다. 내 경우처럼(나는 오래된 Python 3.4를 사용해야 함) 항상 실행 가능한 솔루션은 아닙니다.

감사합니다, @GoldstHa - 정말 유용한 정보입니다. MERGE와 같은 구현을 위해 POC를 만들려고 합니다.

DELETE/INSERT 접근 방식의 문제와 MySQL DB의 @GoldstHa MERGE 접근 방식에 대한 잠재적 차단을 감안할 때 조금 더 파고 sqlalchemy 업데이트 기능을 사용하여 개념 증명을 함께

수정된 접근 방식 제안

API와 upsert가 실제로 어떻게 호출되어야 하는지에 대한 몇 가지 좋은 논의가 있었습니다(즉, 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