c# - 组合Elasticsearch中的字段

Question

假设我在SQL中有一张表，其中将两个字段组合为一个

A    |     B
-----|--------         => select A+' '+ B as Name => BMW X-Series
BMW  |   3-Series
BMW  |     X3

我将其转储到临时表中，并对临时表进行通配符搜索，该结果返回带有count的结果

select Name,count(Name) as frequency from Table where Name like '%3%' group by Name

     Name        Frequency
     ------------------  
    BMW 3-Series |  1
    BMW  X3      |  1

鉴于A和B是单独的字段，现在我如何实现相同的目标。

我尝试了这个:

{ "query":{
      "query_string":{
          "fields":["A","B"],
          "query":"3"
      }
      }, "aggs": {
    "count": {
      "terms": {
        "field": "A"
      },
      "aggs": {
        "count": {
          "terms": {
            "field": "B"
          }

        }
      }
    }
  }

}

如何在查询中添加正则表达式

Answer 1

SQL和Elasticsearch之间的主要区别在于，默认情况下，字符串字段是在索引时进行分析的，您可以控制如何使用Analyzers分析它们。

默认的分析器the Standard Analyzer将根据输入生成 token 并将其存储在反向索引中。您可以使用Analyze API查看给定输入将生成哪些 token :

curl -XPOST "http://localhost:9200/_analyze?analyzer=standard" -d'
{
  text : "3-Series"
}'

产生输出

{
  "tokens": [
    {
      "token": "3",
      "start_offset": 0,
      "end_offset": 1,
      "type": "<NUM>",
      "position": 0
    },
    {
      "token": "series",
      "start_offset": 2,
      "end_offset": 8,
      "type": "<ALPHANUM>",
      "position": 1
    }
  ]
}

知道了这一点，如果使用在搜索时进行分析的搜索查询(例如 the Query String Query)，则如果您以支持用例的方式分析输入，则不需要 regular expression queries或 wildcard queries。

您可以决定在一个字段中索引“BMW 3-Series”，并使用 multi_fields以不同的方式对其进行分析，或者将值保留在单独的字段中，并在两个字段中进行搜索。

这是一个入门的示例。鉴于我们有以下POCO

public class Car
{
    public string Make { get; set; }
    public string Model { get; set; }
}

我们可以建立以下索引

var pool = new SingleNodeConnectionPool(new Uri("http://localhost:9200"));
var carsIndex = "cars";
var connectionSettings = new ConnectionSettings(pool)
        .DefaultIndex(carsIndex);

var client = new ElasticClient(connectionSettings);

client.CreateIndex(carsIndex, ci => ci
    .Settings(s => s
        .Analysis(analysis => analysis
            .Tokenizers(tokenizers => tokenizers
                .Pattern("model-tokenizer", p => p.Pattern(@"\W+"))
            )
            .TokenFilters(tokenfilters => tokenfilters
                .WordDelimiter("model-words", wd => wd
                    .PreserveOriginal()
                    .SplitOnNumerics()
                    .GenerateNumberParts()
                    .GenerateWordParts()
                )
            )
            .Analyzers(analyzers => analyzers
                .Custom("model-analyzer", c => c
                    .Tokenizer("model-tokenizer")
                    .Filters("model-words", "lowercase")
                )
            )
        )
    )
    .Mappings(m => m
        .Map<Car>(mm => mm
            .AutoMap()
            .Properties(p => p
                .String(s => s
                    .Name(n => n.Model)
                    .Analyzer("model-analyzer")
                )
            )
        )
    )
);

我们创建一个 cars索引，并创建一个用于 Model字段的自定义分析器。此自定义分析器会将输入分为任何非单词字符的 token ，然后使用 token 过滤器将 token 拆分为数字字符，以生成保留原始 token ，表示数字部分的 token 和 token 的 token 。代表单词part。最后，所有 token 都小写。

我们可以测试 model-analyzer将对我们的输入执行什么操作，以查看它是否适合我们的需求

curl -XPOST "http://localhost:9200/cars/_analyze?analyzer=model-analyzer" -d'
{
  text : "X3"
}'

产生

{
  "tokens": [
    {
      "token": "x3",
      "start_offset": 0,
      "end_offset": 2,
      "type": "word",
      "position": 0
    },
    {
      "token": "x",
      "start_offset": 0,
      "end_offset": 1,
      "type": "word",
      "position": 0
    },
    {
      "token": "3",
      "start_offset": 1,
      "end_offset": 2,
      "type": "word",
      "position": 1
    }
  ]
}

和

curl -XPOST "http://localhost:9200/cars/_analyze?analyzer=model-analyzer" -d'
{
  text : "3-Series"
}'

产生

{
  "tokens": [
    {
      "token": "3",
      "start_offset": 0,
      "end_offset": 1,
      "type": "word",
      "position": 0
    },
    {
      "token": "series",
      "start_offset": 2,
      "end_offset": 8,
      "type": "word",
      "position": 1
    }
  ]
}

这看起来很适合当前的问题。现在，如果我们为一些文档建立索引并执行搜索，那么我们应该得到想要的结果

client.Index<Car>(new Car { Make = "BMW", Model = "3-Series" });
client.Index<Car>(new Car { Make = "BMW", Model = "X3" });

// refresh the index so that documents are available to search
client.Refresh(carsIndex);

client.Search<Car>(s => s
    .Query(q => q
        .QueryString(qs => qs
            .Fields(f => f
                .Field(c => c.Make)
                .Field(c => c.Model)
            )
            .Query("3")
        )
    )
);

产生以下结果

{
  "took" : 4,
  "timed_out" : false,
  "_shards" : {
    "total" : 2,
    "successful" : 2,
    "failed" : 0
  },
  "hits" : {
    "total" : 2,
    "max_score" : 0.058849156,
    "hits" : [ {
      "_index" : "cars",
      "_type" : "car",
      "_id" : "AVTbhENDDGlNKQ4qnluJ",
      "_score" : 0.058849156,
      "_source" : {
        "make" : "BMW",
        "model" : "3-Series"
      }
    }, {
      "_index" : "cars",
      "_type" : "car",
      "_id" : "AVTbhEOXDGlNKQ4qnluK",
      "_score" : 0.058849156,
      "_source" : {
        "make" : "BMW",
        "model" : "X3"
      }
    } ]
  }
}

希望这给您一些想法。