在es中进行update+upsert

在es中如何做到当一个文档存在，则向某个字段追加内容，如果文档不存在则新建文档

1

USER

给es index操作的时候，如果是同一个id那会执行覆盖操作，那其中某个字段能追加操作而不是覆盖吗

ASSISTANT

在 Elasticsearch 中，如果你使用相同的 _id 执行索引操作（如 index API），默认行为是完全替换文档内容。也就是说，整个文档的内容会被新提供的 JSON 替换掉，而不是对某些字段做“追加”或“局部更新”。

回答你的问题：

如果同一个 id 会覆盖文档，那其中某个字段能追加操作而不是覆盖吗？

✅ 答案是可以的，但必须使用特定的 API 和操作方式。

✅ 实现字段追加的方法

方法一：使用 update API + script

Elasticsearch 提供了脚本更新机制，可以实现字段值的追加操作，比如向数组中添加一个元素。

示例：向数组字段追加一个值

POST your-index/_update/your-doc-id
{
  "script": {
    "source": "ctx._source.your_array_field.add(params.new_value)",
    "params": {
      "new_value": "追加的内容"
    }
  }
}

示例数据：

假设你有如下文档：

{
  "title": "测试文档",
  "tags": ["a", "b"]
}

执行以下 update 脚本：

POST test_index/_update/1
{
  "script": {
    "source": "ctx._source.tags.add(params.new_tag)",
    "params": {
      "new_tag": "c"
    }
  }
}

结果：

{
  "title": "测试文档",
  "tags": ["a", "b", "c"]
}

方法二：使用 update_by_query + script（适用于批量更新）

如果你需要根据某些条件对多个文档进行字段追加，可以用 update_by_query 配合脚本。

POST your-index/_update_by_query
{
  "script": {
    "source": "ctx._source.your_array_field.add(params.new_value)",
    "params": {
      "new_value": "追加内容"
    }
  },
  "query": {
    "match_all": {}
  }
}

方法三：使用 reindex（不推荐用于简单追加）

一般用于复杂字段结构变更，不太适合简单的字段追加。

❗注意事项

  • 使用脚本更新时，Elasticsearch 默认使用 Painless 脚本语言。
  • 如果字段不存在，脚本可能会报错，可以通过判断处理：
    if (ctx._source.containsKey('your_array_field')) {
  ctx._source.your_array_field.add(params.new_value)
} else {
  ctx._source.your_array_field = [params.new_value]
}

🔁 总结

操作方式 是否支持字段追加 说明
index API ❌ 完全替换文档
create API ❌ 只能在文档不存在时插入
update API + script ✅ 推荐方式，可对数组字段追加内容
update_by_query + script ✅ 批量更新场景适用

如果你告诉我你要追加的是什么类型字段（例如字符串、数组、对象等），我可以提供更具体的示例。

2

USER

上面的追加例子[a,b] 追加个[c] 会变成[a b c]，那假设新增的是[b c] 结果会变成怎样

ASSISTANT

你提到的场景是：

  • 原始字段值是数组：["a", "b"]
  • 要追加的是另一个数组：["b", "c"]
  • 你想知道最终结果会是什么？

✅ 正确理解你的问题

你在使用如下脚本进行更新：

"script": {
  "source": "ctx._source.tags.add(params.new_tag)",
  "params": {
    "new_tag": ["b", "c"]
  }
}

那么，tags 字段是数组类型（text 或 keyword 类型的数组），当你调用 .add() 方法时，Elasticsearch 是把整个 ["b", "c"] 当作一个元素来添加。

🧠 所以会发生什么？

原始数据：

{
  "tags": ["a", "b"]
}

执行脚本后变成：

{
  "tags": ["a", "b", ["b", "c"]]
}

也就是说，tags 数组中新增了一个 嵌套数组 元素 ["b", "c"]，变成了三维结构。这不是你想要的结果。

❌ 错误操作说明

.add() 方法是 Java List 的方法，在 Elasticsearch Painless 脚本中也是类似行为：

  • 如果你传入的是单个元素（比如字符串 "c"），它就添加进去；
  • 如果你传入的是一个数组 [ "b", "c" ]，它会把它当作一个整体添加进去，而不是展开合并。

✅ 正确做法：合并两个数组

如果你想把 [ "a", "b" ] 和 [ "b", "c" ] 合并成 [ "a", "b", "b", "c" ]，你应该这样做：

✅ 修改脚本为：

POST your-index/_update/your-doc-id
{
  "script": {
    "source": "ctx._source.tags.addAll(params.new_tags)",
    "params": {
      "new_tags": [ "b", "c" ]
    }
  }
}

这样就会将新数组中的每个元素逐个添加到原数组中，结果为：

{
  "tags": [ "a", "b", "b", "c" ]
}

如果你不希望重复（即去重），你可以先处理一下逻辑，例如在脚本中判断是否已存在该元素。

✅ 如果想去重，可以这样写：

POST your-index/_update/your-doc-id
{
  "script": {
    "source": """
      for (item in params.new_tags) {
        if (!ctx._source.tags.contains(item)) {
          ctx._source.tags.add(item)
        }
      }
    """,
    "params": {
      "new_tags": [ "b", "c" ]
    }
  }
}

这样就能避免重复添加，最终得到：

{
  "tags": [ "a", "b", "c" ]
}

🔁 总结

操作方式 结果 是否推荐
add([b, c]) 添加嵌套数组：[a, b, [b, c]] ❌
addAll([b, c]) 合并为 [a, b, b, c] ✅
addAll() + 去重逻辑 [a, b, c] ✅ 推荐

如需进一步帮助，欢迎告诉我你的具体字段类型和业务需求 😊

3

USER

用python的elasticsearch的包中bulk该怎么写上面那个例子

ASSISTANT

在 Python 中使用 elasticsearch 官方包的 bulk() 方法时，你不能直接执行“追加数组字段”的操作，因为 bulk() 主要用于批量执行索引、创建、更新或删除文档的操作，它本质上是对多个 REST API 操作的封装。

🧩 你的需求总结：

你想用 Python 的 elasticsearch 包 + bulk API 实现以下功能：

  • 对某个文档（已知 _id）：
    • 使用 update 操作
    • 通过脚本向一个数组字段中追加新值（例如：tags 字段）

✅ 正确做法：使用 update 类型 + script

示例结构如下：

from elasticsearch import Elasticsearch, helpers

# 初始化客户端
es = Elasticsearch(hosts=["http://localhost:9200"])

# 准备 actions 数据
actions = [
    {
        "_op_type": "update",  # 表示是 update 操作
        "_index": "your-index-name",
        "_id": "your-doc-id",
        "script": {
            "source": "ctx._source.tags.addAll(params.new_tags)",
            "params": {
                "new_tags": ["b", "c"]
            }
        }
    }
]

# 执行 bulk 操作
helpers.bulk(es, actions)

📌 注意事项

  1. _op_type 必须为 "update"，表示这是 update 类型操作。

  2. script 是顶层参数，而不是放在 _source 或 doc 里。

  3. 如果你想做更复杂的逻辑（比如去重），可以用多行 Painless 脚本：

    "script": {
    "source": """
        for (item in params.new_tags) {
            if (!ctx._source.tags.contains(item)) {
                ctx._source.tags.add(item)
            }
        }
    """,
    "params": {
        "new_tags": ["b", "c"]
    }
}

📦 补充：如果你有多个文档需要批量更新

你可以写多个 action：

actions = [
    {
        "_op_type": "update",
        "_index": "test-index",
        "_id": "1",
        "script": {
            "source": "ctx._source.tags.addAll(params.new_tags)",
            "params": {"new_tags": ["b", "c"]}
        }
    },
    {
        "_op_type": "update",
        "_index": "test-index",
        "_id": "2",
        "script": {
            "source": "ctx._source.tags.addAll(params.new_tags)",
            "params": {"new_tags": ["d", "e"]}
        }
    }
]

helpers.bulk(es, actions)

🔁 小结

功能 写法
使用 bulk 更新文档 _op_type: 'update'
使用脚本更新字段 script: { source: "...", params: {...} }
追加数组字段 使用 .addAll(params.array)
去重追加 使用 for 循环判断 contains()

如果你希望我帮你封装成函数或类，也可以告诉我 😊

4

USER

要带去重功能的

ASSISTANT

好的！下面是使用 Python 的 elasticsearch 官方包，通过 bulk 实现对多个文档进行 带去重功能的数组字段追加更新 的完整示例。

✅ 目标

  • 对多个文档
  • 使用 _id 和索引名
  • 通过脚本向 tags 字段追加新值
  • 只追加不在数组中的元素（去重）

🧩 示例代码（含去重逻辑）

from elasticsearch import Elasticsearch, helpers

# 初始化客户端
es = Elasticsearch(hosts=["http://localhost:9200"])

# 准备批量操作数据
actions = [
    {
        "_op_type": "update",
        "_index": "your-index-name",
        "_id": "doc-1",
        "script": {
            "source": """
                for (item in params.new_tags) {
                    if (!ctx._source.tags.contains(item)) {
                        ctx._source.tags.add(item)
                    }
                }
            """,
            "params": {
                "new_tags": ["b", "c"]
            }
        }
    },
    {
        "_op_type": "update",
        "_index": "your-index-name",
        "_id": "doc-2",
        "script": {
            "source": """
                for (item in params.new_tags) {
                    if (!ctx._source.tags.contains(item)) {
                        ctx._source.tags.add(item)
                    }
                }
            """,
            "params": {
                "new_tags": ["c", "d"]
            }
        }
    }
]

# 执行 bulk 操作
helpers.bulk(es, actions)

📌 脚本说明

这段 Painless 脚本：

for (item in params.new_tags) {
    if (!ctx._source.tags.contains(item)) {
        ctx._source.tags.add(item)
    }
}

作用是：

  • 遍历你传入的新标签列表 new_tags
  • 如果当前文档的 tags 中不包含该标签，则添加进去

📦 封装成函数（可选增强版）

如果你需要多次调用，可以封装成一个函数：

def bulk_update_tags(client, updates):
    actions = []
    for update in updates:
        index = update["index"]
        doc_id = update["id"]
        new_tags = update["new_tags"]

        action = {
            "_op_type": "update",
            "_index": index,
            "_id": doc_id,
            "script": {
                "source": """
                    for (item in params.new_tags) {
                        if (!ctx._source.tags.contains(item)) {
                            ctx._source.tags.add(item)
                        }
                    }
                """,
                "params": {
                    "new_tags": new_tags
                }
            }
        }
        actions.append(action)

    helpers.bulk(client, actions)

使用方式：

updates = [
    {"index": "your-index-name", "id": "doc-1", "new_tags": ["b", "c"]},
    {"index": "your-index-name", "id": "doc-2", "new_tags": ["c", "d"]}
]

bulk_update_tags(es, updates)

✅ 总结

功能 方法
批量更新文档 bulk + _op_type: 'update'
去重追加字段 使用 contains() 判断
多个文档支持 封装为函数处理更清晰

如需我帮你扩展支持其他字段、自动创建索引或异常处理，也可以继续告诉我 😊

5

USER

update能对第一次入库的doc做操作么，比如我事先不知道id为123的doc是不是在es的库中

ASSISTANT

这是一个非常常见的场景：你有一个文档 ID（比如 "123"），你想对这个文档执行一个 更新操作（例如追加字段内容），但你事先不知道这个文档是否已经存在于 Elasticsearch 中。

✅ 简短回答：

update 操作默认要求文档必须存在，否则会抛出 DocumentMissingException 异常。

如果你想在文档不存在时自动创建它，可以使用 upsert 参数！

✅ 正确做法：使用 upsert

示例：使用 Python 的 elasticsearch 包

from elasticsearch import Elasticsearch

es = Elasticsearch()

script_body = {
    "source": """
        for (item in params.new_tags) {
            if (!ctx._source.tags.contains(item)) {
                ctx._source.tags.add(item)
            }
        }
    """,
    "params": {
        "new_tags": ["tag1", "tag2"]
    }
}

# upsert 内容用于当文档不存在时插入
upsert_body = {
    "tags": ["tag1", "tag2"],
    "title": "新文档"
}

es.update(
    index="your-index",
    id="123",
    body={
        "script": script_body,
        "upsert": upsert_body
    }
)

🔍 解释一下参数

参数 说明
index 索引名称
id 文档 ID，如 "123"
script 脚本，用于更新现有文档
upsert 如果文档不存在，则插入这个内容

✅ 行为总结

情况 结果
文档存在 执行脚本更新（比如追加 tags）
文档不存在 插入 upsert 指定的内容作为新文档

📦 在 bulk 中使用 upsert

如果你是用 helpers.bulk() 批量处理多个文档，并希望每个都支持 upsert，你可以这样写：

from elasticsearch import helpers

actions = [
    {
        "_op_type": "update",
        "_index": "your-index",
        "_id": "123",
        "script": {
            "source": """
                for (item in params.new_tags) {
                    if (!ctx._source.tags.contains(item)) {
                        ctx._source.tags.add(item)
                    }
                }
            """,
            "params": {
                "new_tags": ["tag1", "tag2"]
            }
        },
        "upsert": {
            "tags": ["tag1", "tag2"],
            "title": "新文档"
        }
    }
]

helpers.bulk(es, actions)

✅ 总结

操作方式 是否支持“文档不存在”情况 说明
index API ❌ 必须文档不存在才可用
create API ❌ 必须文档不存在才可用
update API + upsert ✅ 推荐方式，既可更新也可创建
update_by_query ❌ 只能用于已有文档
bulk + update + upsert ✅ 支持批量更新/创建

如果你需要我帮你封装成通用函数或根据你的数据结构定制代码，也可以告诉我 😊

8

USER

bulk的action中，针对一个文档能有多个操作吗？就如上面例子写的，如果这个文档不存在则调用upsert，如果存在则update

ASSISTANT

你的问题是：

在 Elasticsearch 的 bulk API 中，一个 action 是否可以对一个文档同时指定多个操作？比如：如果文档不存在则执行 upsert，存在则执行 update。

✅ 简短回答：

不可以，在 bulk 的每个 action 中，你只能为一个文档指定一种操作类型（如 index, create, delete, update）。

但你可以在一个 update 操作中使用 script + upsert 来实现：

  • 如果文档存在 → 执行脚本更新
  • 如果文档不存在 → 插入 upsert 数据

这正是你想要的行为。

✅ 正确理解：bulk 中的 update + upsert 是“原子性”的单一操作

虽然你在 bulk 中写了一个 action，但它内部已经包含了两个逻辑分支：

{
    "_op_type": "update",
    "_index": "your-index",
    "_id": "123",
    "script": { ... },        # 文档存在时执行
    "upsert": { ... }        # 文档不存在时插入
}

这个操作是 Elasticsearch 原生支持的“原子性 upsert”操作，它不是多个操作，而是一个操作的两种可能路径。

❗️错误理解：不能在一个 action 中写多个 _op_type

下面这种写法是不允许的：

{
    "_op_type": "index",     # ❌ 冲突！
    "_id": "123",
    ...
},
{
    "_op_type": "update",    # ❌ 同一个文档不能有两个操作
    "_id": "123",
    ...
}

因为：

  • bulk 的每个 action 只能对应一个文档的一次操作。
  • 多个 action 对同一个文档的操作会被视为独立请求（可能会冲突或覆盖前一个）。

✅ 实际推荐做法：一个文档一个 update + upsert action

示例（Python）：

from elasticsearch import helpers

actions = [
    {
        "_op_type": "update",
        "_index": "test-index",
        "_id": "123",
        "script": {
            "source": """
                for (item in params.new_tags) {
                    if (!ctx._source.tags.contains(item)) {
                        ctx._source.tags.add(item)
                    }
                }
            """,
            "params": {
                "new_tags": ["b", "c"]
            }
        },
        "upsert": {
            "tags": ["b", "c"],
            "title": "新文档"
        }
    }
]

helpers.bulk(es, actions)

行为说明：

文档是否存在 操作行为
存在 使用 script 更新文档（例如追加 tags）
不存在 创建新文档，内容为 upsert 字段

📦 如果你想批量处理多个文档的“存在即更新，不存在即创建”，你可以这样写：

actions = [
    {
        "_op_type": "update",
        "_index": "test-index",
        "_id": "123",
        "script": {...},
        "upsert": {...}
    },
    {
        "_op_type": "update",
        "_index": "test-index",
        "_id": "456",
        "script": {...},
        "upsert": {...}
    }
]

helpers.bulk(es, actions)

✅ 总结

问题 回答
bulk 中能否对一个文档写多个操作？ ❌ 不可以
能否在 bulk 中实现“存在则更新，不存在则创建”？ ✅ 可以，使用 update + upsert
update + upsert 是一个操作还是两个？ ✅ 是一个原子性操作，内部自动判断文档是否存在
脚本和 upsert 能否分别定义字段？ ✅ 可以，脚本用于更新，upsert 定义初始结构

如果你还想进一步封装、动态生成脚本内容或根据业务需求做更复杂的逻辑处理，也可以告诉我，我可以帮你写通用函数 😊

posted @ 2025-06-19 19:06  仙守  阅读(406)  评论(0)    收藏  举报