基于Elasticsearch C# NEST客户端实现自定义字段动态映射问询

我有如下产品模型：

public string Id {get; set;}
public List<FieldValue> Fields { get; set; }

其中FieldValue对象定义为：

public string FieldName {get; set;}
public string FieldType {get; set;}
public List<FieldData> Data  {get;set;}

FieldData定义为：

public string Value {get; set;}

用户可添加任意数量的自定义字段，示例JSON如下：

{
  "Id": "638f1304f2d753647be09c1a",
  "Fields": [
    {
      "FieldName": "Price",
      "FieldType": "double",
      "Data": [{"Value": "14.50"}]
    },
    {
      "FieldName": "Description",
      "FieldType": "string",
      "Data": [{"Value": "Some text here"}]
    }
  ]
}

FieldType支持string、double、int等类型。现在需要对这些产品进行索引，以支持高级搜索：例如将"Price"映射为Elasticsearch的double类型以支持范围查询，将"Description"映射为keyword类型等。

请问是否可以实现一种机制，在产品索引前先检测字段类型，动态创建对应映射（如FieldType为string则映射为keyword，为double则映射为double）？

我使用的是.NET Core 6及最新版NEST客户端，流程为：产品创建事件触发后，从MongoDB获取产品数据，准备映射后索引到Elasticsearch。目前仅使用AutoMap()，了解到动态模板可能符合需求，但不清楚如何在.NET Core中通过NEST客户端实现。

可以实现，推荐两种适配方案：

方式一：使用Elasticsearch动态模板（推荐） #

动态模板能让Elasticsearch根据字段的匹配规则自动应用映射，完美适配自定义字段的动态场景。只需在创建索引时配置一次模板，后续新增字段会自动匹配对应类型。

实现代码 #

var client = new ElasticClient(settings);

// 创建索引并配置动态模板
var createIndexResponse = client.Indices.Create("products", c => c
    .Settings(s => s
        .NumberOfShards(1)
        .NumberOfReplicas(0)
    )
    .Mappings(m => m
        .Map<Product>(mm => mm
            .AutoMap()
            .DynamicTemplates(dt => dt
                // 匹配FieldType为double的字段，映射为ES double类型
                .DynamicTemplate("double_fields", t => t
                    .PathMatch("Fields[*].Data[*].Value")
                    .MatchMappingType("string")
                    .Condition(c => c
                        .Script(s => s
                            .Source("doc['Fields._source.FieldType'].value == 'double'")
                        )
                    )
                    .Mapping(map => map.Double(d => d))
                )
                // 匹配FieldType为int的字段，映射为ES integer类型
                .DynamicTemplate("int_fields", t => t
                    .PathMatch("Fields[*].Data[*].Value")
                    .MatchMappingType("string")
                    .Condition(c => c
                        .Script(s => s
                            .Source("doc['Fields._source.FieldType'].value == 'int'")
                        )
                    )
                    .Mapping(map => map.Integer(i => i))
                )
                // 匹配FieldType为string的字段，映射为ES keyword类型
                .DynamicTemplate("string_fields", t => t
                    .PathMatch("Fields[*].Data[*].Value")
                    .MatchMappingType("string")
                    .Condition(c => c
                        .Script(s => s
                            .Source("doc['Fields._source.FieldType'].value == 'string'")
                        )
                    )
                    .Mapping(map => map.Keyword(k => k))
                )
            )
        )
    )
);

关键说明 #

• PathMatch指定要匹配的字段路径，对应产品模型中Fields数组下每个元素的Data数组内的Value字段。
• Condition通过脚本判断当前字段对应的FieldType值，从而匹配对应的映射规则。
• 注意：使用脚本条件需要在Elasticsearch配置文件elasticsearch.yml中开启动态脚本：script.allowed_types: inline。

方式二：索引前动态构建并更新映射 #

如果不想依赖动态脚本，可以在获取MongoDB数据后，先解析所有自定义字段类型，再手动更新Elasticsearch映射，最后执行索引。

步骤1：解析字段类型映射 #

// 从MongoDB获取产品数据
var products = GetProductsFromMongoDB();

// 收集所有自定义字段的类型映射（去重）
var fieldTypeMappings = new Dictionary<string, string>();
foreach (var product in products)
{
    foreach (var field in product.Fields)
    {
        if (!fieldTypeMappings.ContainsKey(field.FieldName))
        {
            fieldTypeMappings.Add(field.FieldName, field.FieldType);
        }
    }
}

步骤2：动态更新映射 #

// 构建并更新索引映射
var putMappingResponse = client.Indices.PutMapping<Product>("products", m => m
    .Properties(p => p
        .Object<FieldValue>(fv => fv
            .Name(n => n.Fields)
            .Properties(fp => fp
                .Keyword(k => k.Name(f => f.FieldName))
                .Keyword(k => k.Name(f => f.FieldType))
                .Object<FieldData>(fd => fd
                    .Name(f => f.Data)
                    .Properties(dp => 
                    {
                        var propertyDescriptor = new PropertiesDescriptor<FieldData>();
                        foreach (var (_, fieldType) in fieldTypeMappings)
                        {
                            switch (fieldType.ToLower())
                            {
                                case "double":
                                    propertyDescriptor = propertyDescriptor.Double(d => d.Name("Value"));
                                    break;
                                case "int":
                                    propertyDescriptor = propertyDescriptor.Integer(i => i.Name("Value"));
                                    break;
                                case "string":
                                    propertyDescriptor = propertyDescriptor.Keyword(k => k.Name("Value"));
                                    break;
                                // 可扩展其他类型
                            }
                        }
                        return propertyDescriptor;
                    })
                )
            )
        )
    )
);

步骤3：执行索引操作 #

foreach (var product in products)
{
    var indexResponse = client.IndexDocument(product);
}

注意事项 #

1. 动态模板方式更适合字段频繁新增的场景，无需每次索引前手动更新映射。
2. 方式二需保证同一字段的类型全局一致，否则会导致映射更新失败。
3. 确保NEST客户端版本与Elasticsearch服务器版本兼容，避免API差异问题。

内容的提问来源于stack exchange，提问作者Avatar