7.1 脚本 (Scripting)

7.1 脚本 (Scripting)

Elasticsearch 高级特性：深入脚本 (Scripting) 的奥秘

1. 脚本 (Scripting) 的价值与应用场景

Elasticsearch 核心能力在于其高效的搜索和分析能力。然而，在实际应用中，我们往往需要超越简单的关键词匹配和聚合统计，进行更加精细化和定制化的操作。这时，脚本就显得尤为重要。

脚本允许我们在 Elasticsearch 的多个环节注入自定义的逻辑，从而实现：

• 动态字段计算 (Dynamic Field Calculation): 在查询时，根据文档的现有字段，实时计算出新的字段，无需预先索引。例如，根据商品的价格和折扣率，动态计算出折后价。

• 自定义评分 (Custom Scoring): 默认的评分机制可能无法完全满足复杂的业务需求。脚本可以让我们根据文档的各种属性，编写自定义的评分逻辑，更精准地控制搜索结果的排序。例如，根据商品的销量、用户评价、发布时间等因素，综合计算商品的相关性得分。

• 条件更新 (Conditional Update): 在更新文档时，可以根据文档的当前状态，有条件地执行更新操作，避免并发冲突和数据不一致。例如，只有当商品的库存大于指定数量时，才允许扣减库存。

• 数据转换与富化 (Data Transformation and Enrichment): 在数据摄入 (Ingest) 阶段，可以使用脚本对数据进行清洗、转换和富化，使其更符合索引和分析的需求。例如，将日期字符串转换为日期类型，根据地理位置信息添加城市和国家信息。

• 更复杂的查询逻辑 (Complex Query Logic): 脚本可以嵌入到查询语句中，实现更复杂的条件判断和数据过滤，例如，根据多个字段的组合条件进行筛选。

总而言之，脚本为 Elasticsearch 提供了强大的灵活性和可扩展性，使得我们可以根据具体的业务需求，定制和优化 Elasticsearch 的行为，从而更好地满足各种复杂场景的需求。

2. Elasticsearch 中的脚本语言：Painless

在 Elasticsearch 中， Painless 是默认且官方推荐的脚本语言。Painless 是一种专门为 Elasticsearch 设计的安全、高性能的脚本语言。相比于早期的 Groovy、JavaScript 等脚本语言，Painless 在安全性和性能方面做了大量的优化：

• 安全性 (Security): Painless 被设计为沙箱环境运行，限制了对系统资源的访问，有效防止了恶意脚本的注入和执行，大大提高了 Elasticsearch 的安全性。

• 性能 (Performance): Painless 针对 Elasticsearch 的数据结构和操作进行了优化，编译执行速度快，资源消耗低，能够满足高并发、低延迟的场景需求。

• 易用性 (Usability): Painless 语法简洁明了，学习曲线平缓，即使没有编程经验的用户也能快速上手。同时，Elasticsearch 提供了丰富的 Painless API 文档和示例，方便开发者学习和使用。

虽然 Elasticsearch 仍然支持其他脚本语言，例如 expression 和 mustache，但 Painless 无疑是首选。本文将主要围绕 Painless 脚本进行讲解和实践。

图 1: Elasticsearch 脚本执行流程

图 1 简单展示了 Elasticsearch 脚本的执行流程。当 Elasticsearch 接收到包含脚本的请求时，脚本引擎 (Painless Engine) 会加载并执行 Painless 脚本，脚本可以访问 Elasticsearch 的数据，并根据业务逻辑进行处理，最终返回脚本执行结果。

3. Painless 脚本核心概念与语法基础

3.1 基础语法

Painless 的语法借鉴了 Java 和 JavaScript，对于熟悉这些语言的开发者来说，上手非常容易。以下是一些 Painless 的基础语法元素：

• 变量声明: 使用 def 关键字声明变量，Painless 会自动进行类型推断。也可以显式指定类型，例如 int count = 0;。

• 数据类型: 支持基本数据类型，如 int, long, float, double, boolean, String，以及数组 List, Map 等集合类型。

• 运算符: 支持常见的算术运算符 (+, -, *, /, %)、比较运算符 (==, !=, >, <, >=, <=)、逻辑运算符 (&&, ||, !) 等。

• 控制语句: 支持 if-else 条件判断语句、for 和 while 循环语句。

• 函数: 支持自定义函数，使用 def 关键字定义函数，可以有返回值和参数。

示例代码 1: 简单的 Painless 脚本示例

def price = doc['price'].value;
def discount = doc['discount_rate'].value;
def discountedPrice = price * (1 - discount);
return discountedPrice;
​

这段脚本从文档中获取 price 和 discount_rate 字段的值，计算折后价 discountedPrice，并返回计算结果。

3.2 访问文档字段：doc['field_name'].value

在 Painless 脚本中，访问文档字段是核心操作之一。我们使用 doc['field_name'].value 的方式来获取文档中 field_name 字段的值。

• doc['field_name']: 返回一个 ScriptDocValues 对象，它提供了访问字段值的接口。

• .value: 获取字段的单个值。如果字段是多值字段，则默认返回第一个值。可以使用 .values 获取所有值，返回一个 List。

示例代码 2: 访问不同类型的字段

// 访问 keyword 类型字段
def productName = doc['product_name.keyword'].value;
// 访问 integer 类型字段
def stockQuantity = doc['stock_quantity'].value;
// 访问 date 类型字段
def publishDate = doc['publish_date'].value;
// 访问多值字段 (例如 tags)
def tags = doc['tags'].values;
for (def tag : tags) {
  // 处理每个 tag
  // ...
}
​

3.3 上下文变量 (Context Variables)

Elasticsearch 在不同的脚本执行上下文中，会提供不同的上下文变量，方便脚本访问相关信息。常用的上下文变量包括：

• _source: 访问文档的 _source 字段，以 Map 的形式返回文档的原始 JSON 数据。使用 _source.field_name 可以直接访问字段值。

• _fields: 访问文档的存储字段 (stored fields)。存储字段是指在索引时显式指定 store: true 的字段。_fields 返回一个 Map，键是字段名，值是 ScriptDocValues 对象。

• params: 允许在脚本外部传递参数到脚本内部。可以通过 params.param_name 访问外部参数。

• _score: 在查询上下文中，访问当前文档的评分。

• _index: 当前文档所在的索引名称。

• _type (Deprecated in 7.x): 在 Elasticsearch 中 Type 已经被移除，_type 变量不再使用。

• _id: 当前文档的 ID。

• _routing: 当前文档的路由值。

• _version: 当前文档的版本号。

示例代码 3: 使用上下文变量

// 使用 _source 访问字段
def category = _source.category;
// 使用 params 访问外部参数
def threshold = params.threshold;
if (doc['price'].value > threshold) {
  return true;
} else {
  return false;
}
​

3.4 内置函数和 API

Painless 提供了丰富的内置函数和 API，用于进行各种数据处理和操作。常用的包括：

• 字符串函数: startsWith(), endsWith(), contains(), substring(), toLowerCase(), toUpperCase(), length() 等。

• 数值函数: Math.abs(), Math.min(), Math.max(), Math.round(), Math.ceil(), Math.floor() 等。

• 日期函数: Instant.parse(), ZonedDateTime.parse(), DateTimeFormatter (需要 import java.time.*) 等日期时间处理 API。

• 集合函数: List 的 add(), remove(), contains(), size() 等方法，Map 的 get(), put(), containsKey(), size() 等方法。

• JSON 处理: JsonSlurper 和 JsonOutput 类 (需要 import groovy.json.*) 用于解析和生成 JSON 数据。

• Geo 函数: geo_distance(), geo_point() 等地理位置函数。

• Logging: logger.info(), logger.debug(), logger.warn(), logger.error() 等日志记录功能。

示例代码 4: 使用内置函数和 API

// 字符串操作
def productName = doc['product_name.keyword'].value;
if (productName.toLowerCase().contains('apple')) {
  // ...
}
// 数值计算
def price = doc['price'].value;
def roundedPrice = Math.round(price);
// 日期处理
import java.time.*;
import java.time.format.*;
def dateString = doc['publish_date'].value;
def dateTimeFormatter = DateTimeFormatter.ISO_DATE_TIME;
def publishDateTime = ZonedDateTime.parse(dateString, dateTimeFormatter);
def dayOfWeek = publishDateTime.getDayOfWeek().toString();
// JSON 处理
import groovy.json.*;
def jsonString = '{"name": "product1", "price": 100}';
def jsonSlurper = new JsonSlurper();
def jsonData = jsonSlurper.parseText(jsonString);
def productNameFromJson = jsonData.name;
​

4. 脚本实践：代码示例与应用场景

接下来，我们将通过具体的代码示例，演示 Painless 脚本在 Elasticsearch 中的应用。

4.1 脚本字段 (Script Fields)

脚本字段允许我们在查询结果中动态添加计算字段，而无需修改索引数据。这对于临时性的数据分析和展示非常有用。

示例代码 5: 使用脚本字段计算商品折后价

GET /products/_search
{
  "query": {
    "match_all": {}
  },
  "script_fields": {
    "discounted_price": {
      "script": {
        "source": "doc['price'].value * (1 - doc['discount_rate'].value)",
        "lang": "painless"
      }
    }
  }
}
​

代码解释:

• script_fields: 定义脚本字段。

• discounted_price: 脚本字段的名称。

• script: 定义脚本内容。

  • source: Painless 脚本代码，计算折后价。

  • lang: 指定脚本语言为 "painless"。

返回结果示例:

{
  "hits": {
    "hits": [
      {
        "_source": {
          "product_name": "Product A",
          "price": 100,
          "discount_rate": 0.1
        },
        "fields": {
          "discounted_price": [
            90.0
          ]
        }
      },
      // ... more hits
    ]
  }
}
​

在返回结果的 fields 部分，可以看到我们动态计算的 discounted_price 字段。

4.2 脚本查询 (Script Queries) - Function Score Query

Function Score Query 允许我们使用脚本自定义文档的评分，从而更灵活地控制搜索结果的排序。

示例代码 6: 使用脚本提升销量高的商品的排名

GET /products/_search
{
  "query": {
    "function_score": {
      "query": {
        "match": {
          "product_name": "product"
        }
      },
      "functions": [
        {
          "script_score": {
            "script": {
              "source": "_score + doc['sales_volume'].value * 0.01",
              "lang": "painless"
            }
          }
        }
      ],
      "boost_mode": "replace"
    }
  }
}
​

代码解释:

• function_score: 使用 Function Score Query。

• query: 基础查询，这里使用 match 查询搜索商品名称包含 "product" 的商品。

• functions: 定义评分函数列表。

  • script_score: 使用脚本评分函数。

    • script: 定义评分脚本。

      • source: Painless 脚本代码，将原始评分 _score 加上销量 sales_volume 的一定比例，从而提升销量高的商品的排名。

      • lang: 指定脚本语言为 "painless"。

• boost_mode: 指定评分函数的组合方式，replace 表示用脚本计算的评分替换原始评分。

通过这个例子，我们可以看到如何使用脚本自定义评分逻辑，根据业务需求调整搜索结果的排序。

4.3 更新脚本 (Update Scripts)

Update API 允许我们使用脚本更新文档的字段。脚本可以在更新过程中访问文档的当前状态，并根据需要进行修改。

示例代码 7: 使用脚本原子性地增加商品库存

POST /products/_update/1
{
  "script": {
    "source": "ctx._source.stock_quantity += params.quantity",
    "lang": "painless",
    "params": {
      "quantity": 10
    }
  }
}
​

代码解释:

• POST /products/_update/1: 更新 products 索引中 ID 为 1 的文档。

• script: 定义更新脚本。

  • source: Painless 脚本代码，ctx._source 可以访问文档的 _source 字段，ctx._source.stock_quantity += params.quantity 将库存字段的值增加 params.quantity。

  • lang: 指定脚本语言为 "painless"。

  • params: 传递参数，这里传递了要增加的库存数量 quantity。

ctx 上下文变量:

在 Update Script 中，我们使用 ctx 上下文变量来访问和修改文档。ctx 提供了以下属性：

• ctx._source: 访问文档的 _source 字段，可以读取和修改字段值。

• ctx._index: 文档所在的索引名称。

• ctx._type (Deprecated in 7.x): 不再使用。

• ctx._id: 文档的 ID。

• ctx._routing: 文档的路由值。

• ctx._version: 文档的版本号。

• ctx.op: 更新操作类型，可以是 "create", "index", "update", "delete"。

• ctx.params: 访问脚本外部传递的参数。

Update Script 的原子性保证了在高并发场景下，数据更新的正确性。

4.4 Ingest Pipeline 脚本处理器 (Script Processor)

Ingest Pipeline 允许我们在数据索引之前，对数据进行预处理。Script Processor 是 Ingest Pipeline 中一个强大的处理器，可以使用脚本对数据进行转换和富化。

示例代码 8: 使用 Ingest Pipeline 脚本处理器将日期字符串转换为日期类型

PUT /_ingest/pipeline/date_conversion_pipeline
{
  "description": "Convert date string to date type",
  "processors": [
    {
      "script": {
        "lang": "painless",
        "source": """
          import java.time.*;
          import java.time.format.*;
          def dateString = ctx.publish_date_string;
          if (dateString != null) {
            def dateTimeFormatter = DateTimeFormatter.ISO_DATE_TIME;
            def publishDateTime = ZonedDateTime.parse(dateString, dateTimeFormatter);
            ctx.publish_date = publishDateTime;
            ctx.remove('publish_date_string'); // 删除原始字符串字段
          }
        """
      }
    }
  ]
}
​

代码解释:

• PUT /_ingest/pipeline/date_conversion_pipeline: 创建名为 date_conversion_pipeline 的 Ingest Pipeline。

• processors: 定义处理器列表。

  • script: 使用 Script Processor。

    • lang: 指定脚本语言为 "painless"。

    • source: Painless 脚本代码，将 publish_date_string 字段的值解析为日期类型，并赋值给 publish_date 字段，最后删除原始的字符串字段 publish_date_string。

测试 Ingest Pipeline:

POST /_ingest/pipeline/date_conversion_pipeline/_simulate?verbose
{
  "docs": [
    {
      "_source": {
        "product_name": "Product C",
        "publish_date_string": "2023-10-27T10:00:00Z"
      }
    }
  ]
}
​

在索引数据时，我们可以指定使用这个 Ingest Pipeline：

PUT /products/_doc/3?pipeline=date_conversion_pipeline
{
  "product_name": "Product D",
  "publish_date_string": "2023-10-28T14:30:00Z"
}
​

通过 Ingest Pipeline 的 Script Processor，我们可以在数据进入 Elasticsearch 之前，对其进行灵活的处理和转换，保证数据质量。

5. 脚本性能优化与安全考量

虽然 Painless 脚本性能较高，但仍然需要注意一些性能优化和安全考量：

• 脚本缓存 (Script Caching): Elasticsearch 会缓存编译后的脚本，提高脚本的执行效率。对于常用的脚本，尽量使用预编译脚本或存储脚本，避免每次都编译脚本。

• 避免高开销操作: 在脚本中避免进行高开销的操作，例如复杂的循环、大量的字符串操作、正则表达式匹配等。尽量将复杂逻辑放在 Elasticsearch 外部处理。

• 限制脚本资源: 可以通过 Elasticsearch 的配置，限制脚本的执行时间和内存消耗，防止恶意脚本或性能不佳的脚本影响 Elasticsearch 的稳定性。

• 脚本安全策略: Painless 本身已经做了很多安全限制，但仍然需要注意脚本的编写，避免访问不必要的系统资源，防止潜在的安全风险。

• 脚本测试与调试: 在生产环境部署脚本之前，务必进行充分的测试和调试，确保脚本的正确性和性能。可以使用 _scripts/painless/_execute API 测试脚本，并使用日志记录功能进行调试。

6. 总结与展望

Elasticsearch 的脚本 (Scripting) 功能，特别是基于 Painless 脚本语言，为我们提供了强大的定制化能力。无论是动态字段计算、自定义评分、条件更新，还是数据转换富化，脚本都扮演着不可或缺的角色。

通过本文的详细讲解和代码实践，相信您已经对 Elasticsearch 脚本有了更深入的理解。在实际应用中，灵活运用脚本功能，可以帮助我们更好地解决各种复杂的数据处理和分析问题，充分发挥 Elasticsearch 的强大潜力。

随着 Elasticsearch 技术的不断发展，脚本功能也将持续演进和完善，为我们带来更多可能性。掌握脚本技术，将是成为 Elasticsearch 高级用户的关键一步。

希望本文能够帮助您在 Elasticsearch 的脚本世界中更进一步！