如何使用SqlAlchemy进行upsert？

76

我有一个记录，我想在数据库中存在该记录，如果它不存在，并且已经存在（存在主键），我希望将字段更新为当前状态。这通常被称为upsert。

以下不完整的代码段演示了有效的方法，但似乎过于笨拙（尤其是如果有更多的列）。什么是更好/最好的方法？

Base = declarative_base()
class Template(Base):
    __tablename__ = 'templates'
    id = Column(Integer, primary_key = True)
    name = Column(String(80), unique = True, index = True)
    template = Column(String(80), unique = True)
    description = Column(String(200))
    def __init__(self, Name, Template, Desc):
        self.name = Name
        self.template = Template
        self.description = Desc

def UpsertDefaultTemplate():
    sess = Session()
    desired_default = Template("default", "AABBCC", "This is the default template")
    try:
        q = sess.query(Template).filter_by(name = desiredDefault.name)
        existing_default = q.one()
    except sqlalchemy.orm.exc.NoResultFound:
        #default does not exist yet, so add it...
        sess.add(desired_default)
    else:
        #default already exists.  Make sure the values are what we want...
        assert isinstance(existing_default, Template)
        existing_default.name = desired_default.name
        existing_default.template = desired_default.template
        existing_default.description = desired_default.description
    sess.flush()

是否有更好或更详细的方法？这样的事情会很棒：

sess.upsert_this(desired_default, unique_key = "name")

尽管unique_keykwarg显然是不必要的（ORM应该能够轻松解决这一问题），但我添加它只是因为SQLAlchemy倾向于仅使用主键。例如：我一直在研究Session.merge是否适用，但这仅适用于主键，在这种情况下，这是一个自动递增的ID，对于此目的并不是非常有用。

一个简单的示例用例就是在启动可能已升级其默认预期数据的服务器应用程序时。即：此并发问题不涉及并发问题。

python  sqlalchemy  upsert 
— 拉斯
source
3
name如果字段是唯一的，为什么不能将其设为主键（在这种情况下，合并将起作用）。为什么需要一个单独的主键？
— 方丈
12
@abbot：我不想参加id领域的辩论，但是...简短的答案是“外键”。较长的一点是，尽管名称确实是唯一需要的唯一键，但是存在两个问题。1）当模板记录被另一个以FK作为字符串字段的表中的5000万条记录引用时，则为坚果。带索引的整数更好，因此看似毫无意义的id列。2）上延伸，如果字符串被用作FK，现在有更新的名称，如果/当它改变时，这是非常讨厌，充斥着死亡的关系问题的两个位置。编号永远不会改变。
— 罗斯，
您可以尝试使用适用于python的新（测试版）upsert库...它与psycopg2，sqlite3，MySQLdb兼容
— Seamus Abshere 2012年
— 漂流守望者

Answers:

56

SQLAlchemy确实具有“保存或更新”行为，在最近的版本中已经内置了该行为session.add，但以前是单独的session.saveorupdate调用。这不是“ upsert”，但可能足以满足您的需求。

您最好询问具有多个唯一键的类。我相信，这正是没有单一正确方法执行此操作的原因。主键也是唯一键。如果没有唯一的约束，只有主键，那将是一个简单的问题：如果不存在具有给定ID的对象，或者如果ID为None，则创建一个新记录；否则，使用该主键更新现有记录中的所有其他字段。

但是，当存在其他唯一约束时，该简单方法就会存在逻辑问题。如果要“更新”对象，并且对象的主键与现有记录匹配，而另一个唯一列与其他记录匹配，那么您该怎么办？同样，如果主键不匹配现有的记录，但另一种独特的列不匹配现有的记录，然后呢？对于您的特定情况，可能会有正确的答案，但总的来说，我会认为没有一个正确的答案。

这就是没有内置“ upsert”操作的原因。应用程序必须定义每种情况下的含义。

— 草莓
source
36

SQLAlchemy支持ON CONFLICT两种方法on_conflict_do_update()和on_conflict_do_nothing()。

从文档中复制：

from sqlalchemy.dialects.postgresql import insert

stmt = insert(my_table).values(user_email='a@b.com', data='inserted data')
stmt = stmt.on_conflict_do_update(
    index_elements=[my_table.c.user_email],
    index_where=my_table.c.user_email.like('%@gmail.com'),
    set_=dict(data=stmt.excluded.data)
)
conn.execute(stmt)
— 公关
source
1
— Michael Berdyshev，
只是execute无法获得返回的ID
— jiamo
该代码是的，我认为（答案已有3年以上），但也许Michaels的注释适用于MySQL。一般来说，我的（这个）答案有点跳到将postgres用作数据库的结论。这不是很好，因为它不能真正回答所提出的一般性问题。但是基于我的投票，我认为它对某些人有用，所以我放弃了。
— PR
14

如今，SQLAlchemy提供了两个有用的功能on_conflict_do_nothing和on_conflict_do_update。这些功能很有用，但是需要您从ORM界面切换到较低级别的一个SQLAlchemy Core。

尽管这两个功能使使用SQLAlchemy语法进行加粗处理并不那么困难，但是这些功能远不能为加粗处理提供完整的现成解决方案。

我的常见用例是在单个SQL查询/会话执行中插入大量行。我通常会遇到两个问题：

例如，我们已经习惯了更高级别的ORM功能。您不能使用ORM对象，而必须ForeignKey在插入时提供。

我用这下面的函数我写来处理这两个问题：

def upsert(session, model, rows):
    table = model.__table__
    stmt = postgresql.insert(table)
    primary_keys = [key.name for key in inspect(table).primary_key]
    update_dict = {c.name: c for c in stmt.excluded if not c.primary_key}

    if not update_dict:
        raise ValueError("insert_or_update resulted in an empty update_dict")

    stmt = stmt.on_conflict_do_update(index_elements=primary_keys,
                                      set_=update_dict)

    seen = set()
    foreign_keys = {col.name: list(col.foreign_keys)[0].column for col in table.columns if col.foreign_keys}
    unique_constraints = [c for c in table.constraints if isinstance(c, UniqueConstraint)]
    def handle_foreignkeys_constraints(row):
        for c_name, c_value in foreign_keys.items():
            foreign_obj = row.pop(c_value.table.name, None)
            row[c_name] = getattr(foreign_obj, c_value.name) if foreign_obj else None

        for const in unique_constraints:
            unique = tuple([const,] + [row[col.name] for col in const.columns])
            if unique in seen:
                return None
            seen.add(unique)

        return row

    rows = list(filter(None, (handle_foreignkeys_constraints(row) for row in rows)))
    session.execute(stmt, rows)
— 尼尔兹
source
5
on_conflict仅适用于支持本机ON CONFLICT封装的后端。因此，只有postgresql
— cowbert
4
@cowbert现在，SQLAlchemy还支持MySQL的ON DUPLICATE KEY UPDATE。
— Michael Berdyshev
12

我使用“三思而后行”的方法：

# first get the object from the database if it exists
# we're guaranteed to only get one or zero results
# because we're filtering by primary key
switch_command = session.query(Switch_Command).\
    filter(Switch_Command.switch_id == switch.id).\
    filter(Switch_Command.command_id == command.id).first()

# If we didn't get anything, make one
if not switch_command:
    switch_command = Switch_Command(switch_id=switch.id, command_id=command.id)

# update the stuff we care about
switch_command.output = 'Hooray!'
switch_command.lastseen = datetime.datetime.utcnow()

session.add(switch_command)
# This will generate either an INSERT or UPDATE
# depending on whether we have a new object or not
session.commit()

优点是，这是db-neutral，并且我认为很容易阅读。缺点是，在类似以下情况的情况下存在潜在的竞争条件：

  • 我们在数据库中查询aswitch_command而找不到一个
  • 我们创建一个 switch_command
  • 另一个进程或线程使用switch_command与我们相同的主键创建一个
  • 我们尝试承诺 switch_command
— 本
source
这个问题通过尝试/接球来解决比赛条件
— Ben
5
upsert的整个目标是避免此处描述的竞争状况。
— sampierson
@sampierson我的专有技术，这就是为什么它是很可悲的是SQLAlchemy的，难以清洁的和可移植做......我强调我的回答竞态条件
— 奔
2

以下内容对我来说适合Redshift数据库，也可以用于组合主键约束。

消息来源：此

在函数def start_engine（）中创建SQLAlchemy引擎所需的修改很少 

from sqlalchemy import Column, Integer, Date ,Metadata
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.dialects.postgresql import insert
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from sqlalchemy.dialects import postgresql

Base = declarative_base()

def start_engine():
    engine = create_engine(os.getenv('SQLALCHEMY_URI', 
    'postgresql://localhost:5432/upsert'))
     connect = engine.connect()
    meta = MetaData(bind=engine)
    meta.reflect(bind=engine)
    return engine


class DigitalSpend(Base):
    __tablename__ = 'digital_spend'
    report_date = Column(Date, nullable=False)
    day = Column(Date, nullable=False, primary_key=True)
    impressions = Column(Integer)
    conversions = Column(Integer)

    def __repr__(self):
        return str([getattr(self, c.name, None) for c in self.__table__.c])


def compile_query(query):
    compiler = query.compile if not hasattr(query, 'statement') else 
  query.statement.compile
    return compiler(dialect=postgresql.dialect())


def upsert(session, model, rows, as_of_date_col='report_date', no_update_cols=[]):
    table = model.__table__

    stmt = insert(table).values(rows)

    update_cols = [c.name for c in table.c
                   if c not in list(table.primary_key.columns)
                   and c.name not in no_update_cols]

    on_conflict_stmt = stmt.on_conflict_do_update(
        index_elements=table.primary_key.columns,
        set_={k: getattr(stmt.excluded, k) for k in update_cols},
        index_where=(getattr(model, as_of_date_col) < getattr(stmt.excluded, as_of_date_col))
        )

    print(compile_query(on_conflict_stmt))
    session.execute(on_conflict_stmt)


session = start_engine()
upsert(session, DigitalSpend, initial_rows, no_update_cols=['conversions'])
— 阿迪蒂·斯里瓦斯塔瓦（Aditi Srivastava）
source
1

这允许基于字符串名称访问基础模型

def get_class_by_tablename(tablename):
  """Return class reference mapped to table.
  /programming/11668355/sqlalchemy-get-model-from-table-name-this-may-imply-appending-some-function-to
  :param tablename: String with name of table.
  :return: Class reference or None.
  """
  for c in Base._decl_class_registry.values():
    if hasattr(c, '__tablename__') and c.__tablename__ == tablename:
      return c


sqla_tbl = get_class_by_tablename(table_name)

def handle_upsert(record_dict, table):
    """
    handles updates when there are primary key conflicts

    """
    try:
        self.active_session().add(table(**record_dict))
    except:
        # Here we'll assume the error is caused by an integrity error
        # We do this because the error classes are passed from the
        # underlying package (pyodbc / sqllite) SQLAlchemy doesn't mask
        # them with it's own code - this should be updated to have
        # explicit error handling for each new db engine

        # <update>add explicit error handling for each db engine</update> 
        active_session.rollback()
        # Query for conflic class, use update method to change values based on dict
        c_tbl_primary_keys = [i.name for i in table.__table__.primary_key] # List of primary key col names
        c_tbl_cols = dict(sqla_tbl.__table__.columns) # String:Col Object crosswalk

        c_query_dict = {k:record_dict[k] for k in c_tbl_primary_keys if k in record_dict} # sub-dict from data of primary key:values
        c_oo_query_dict = {c_tbl_cols[k]:v for (k,v) in c_query_dict.items()} # col-object:query value for primary key cols

        c_target_record = session.query(sqla_tbl).filter(*[k==v for (k,v) in oo_query_dict.items()]).first()

        # apply new data values to the existing record
        for k, v in record_dict.items()
            setattr(c_target_record, k, v)
— 沙尔顿
source
0

这适用于sqlite3和postgres。尽管它可能会因结合了主键约束而失败，并且极有可能因附加的唯一约束而失败。

    try:
        t = self._meta.tables[data['table']]
    except KeyError:
        self._log.error('table "%s" unknown', data['table'])
        return

    try:
        q = insert(t, values=data['values'])
        self._log.debug(q)
        self._db.execute(q)
    except IntegrityError:
        self._log.warning('integrity error')
        where_clause = [c.__eq__(data['values'][c.name]) for c in t.c if c.primary_key]
        update_dict = {c.name: data['values'][c.name] for c in t.c if not c.primary_key}
        q = update(t, values=update_dict).where(*where_clause)
        self._log.debug(q)
        self._db.execute(q)
    except Exception as e:
        self._log.error('%s: %s', t.name, e)
— 塞乔
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.