NEST - 编写布尔查询

最新推荐文章于 2024-01-05 23:30:29 发布
最新推荐文章于 2024-01-05 23:30:29 发布
阅读量165 收藏
点赞数
文章标签： c/c++ json
原文链接：http://www.cnblogs.com/WessonStar/p/8323875.html
版权

Writing bool queries

Version：5.x

英文原文地址：Writing bool queries

在使用查询 DSL 时，编写 bool 查询会很容易把代码变得冗长。举个栗子，使用一个包含两个 should 子句的 bool 查询

var searchResults = this.Client.Search<Project>(s => s
    .Query(q => q
        .Bool(b => b
            .Should(
                bs => bs.Term(p => p.Name, "x"),
                bs => bs.Term(p => p.Name, "y")
            )
        )
    )
);

现在设想多层嵌套的 bool 查询，你会意识到这很快就会成为一个 hadouken（波动拳） 缩进的练习

img

Operator overloading

由于这个原因，NEST 引入了运算符重载，使得更容易去编写复杂的 bool 查询。这些重载的运算符是：

我们会示例来演示这几个运算符

Binary || operator

使用重载的二元 || 运算符，可以更简洁地表达含有 should 子句的 bool 查询

之前哈杜根的栗子现在变成了 Fluent API 的样子

var firstSearchResponse = client.Search<Project>(s => s
    .Query(q => q
        .Term(p => p.Name, "x") || q
        .Term(p => p.Name, "y")
    )
);

使用 Object Initializer 语法

var secondSearchResponse = client.Search<Project>(new SearchRequest<Project>
{
    Query = new TermQuery { Field = Field<Project>(p => p.Name), Value = "x" } ||
            new TermQuery { Field = Field<Project>(p => p.Name), Value = "y" }
});

两者都会生成如下 JSON 查询 DSL

{
  "query": {
    "bool": {
      "should": [
        {
          "term": {
            "name": {
              "value": "x"
            }
          }
        },
        {
          "term": {
            "name": {
              "value": "y"
            }
          }
        }
      ]
    }
  }
}

Binary && operator

重载的二元 && 运算符用于将多个查询组合在一起。当要组合的查询没有应用任何一元运算符时，生成的查询是一个包含 must 子句的 bool 查询

var firstSearchResponse = client.Search<Project>(s => s
    .Query(q => q
        .Term(p => p.Name, "x") && q
        .Term(p => p.Name, "y")
    )
);

使用 Object Initializer 语法

var secondSearchResponse = client.Search<Project>(new SearchRequest<Project>
{
    Query = new TermQuery { Field = Field<Project>(p => p.Name), Value = "x" } &&
            new TermQuery { Field = Field<Project>(p => p.Name), Value = "y" }
});

两者都会生成如下 JSON 查询 DSL

{
  "query": {
    "bool": {
      "must": [
        {
          "term": {
            "name": {
              "value": "x"
            }
          }
        },
        {
          "term": {
            "name": {
              "value": "y"
            }
          }
        }
      ]
    }
  }
}

运算符重载会重写原生的实现

term && term && term

会转换成

bool
|___must
   |___term
   |___bool
       |___must
           |___term
           |___term

可以想象，随着查询变得越来越复杂，结果很快就会变得笨拙。NEST 是很聪明的，它会把多个 && 查询联合成一个 bool 查询

bool
|___must
   |___term
   |___term
   |___term

如下所示

Assert(
    q => q.Query() && q.Query() && q.Query(), (1)
    Query && Query && Query, (2)
    c => c.Bool.Must.Should().HaveCount(3) (3) 
);

(1) 使用 Fluent API 将三个查询 && 在一起

(2) 使用 Object Initializer 语法将三个查询 && 在一起

(3) 断言最终的 bool 查询会包含 3 个 must 子句

Unary ! operator

NEST 使用一元 ! 运算符创建包含 must_not 子句的 bool 查询

var firstSearchResponse = client.Search<Project>(s => s
    .Query(q => !q
        .Term(p => p.Name, "x")
    )
);

使用 Object Initializer 语法

var secondSearchResponse = client.Search<Project>(new SearchRequest<Project>
{
    Query = !new TermQuery { Field = Field<Project>(p => p.Name), Value = "x" }
});

两者都会生成如下 JSON 查询 DSL

{
  "query": {
    "bool": {
      "must_not": [
        {
          "term": {
            "name": {
              "value": "x"
            }
          }
        }
      ]
    }
  }
}

用一元 ! 运算符标记的两个查询可以使用 and 运算符组合起来，从而形成一个包含两个 must_not 子句的 bool 查询

Assert(
    q => !q.Query() && !q.Query(), 
    !Query && !Query, 
    c => c.Bool.MustNot.Should().HaveCount(2));

Unary + operator

可以使用一元 + 运算符将查询转换为带有 filter 子句的 bool 查询

var firstSearchResponse = client.Search<Project>(s => s
    .Query(q => +q
        .Term(p => p.Name, "x")
    )
);

使用 Object Initializer 语法

var secondSearchResponse = client.Search<Project>(new SearchRequest<Project>
{
    Query = +new TermQuery { Field = Field<Project>(p => p.Name), Value = "x" }
});

两者都会生成如下 JSON 查询 DSL

{
  "query": {
    "bool": {
      "filter": [
        {
          "term": {
            "name": {
              "value": "x"
            }
          }
        }
      ]
    }
  }
}

在筛选上下文中运行查询，这在提高性能方面很有用。因为不需要计算查询的相关性评分来影响结果的顺序。

同样的，使用一元 + 运算符标记的查询可以和 && 运算符组合在一起，构成一个包含两个 filter 子句的 bool 查询

Assert(
    q => +q.Query() && +q.Query(),
    +Query && +Query,
    c => c.Bool.Filter.Should().HaveCount(2));

Combining bool queries

在使用二元 && 运算符组合多个查询时，如果某些或者全部的查询都应用了一元运算符，NEST 仍然可以把它们合并成一个 bool 查询

参考下面这个 bool 查询

bool
|___must
|   |___term
|   |___term
|   |___term
|
|___must_not
   |___term

NEST 中可以这样构建

Assert(
    q => q.Query() && q.Query() && q.Query() && !q.Query(),
    Query && Query && Query && !Query,
    c=>
    {
        c.Bool.Must.Should().HaveCount(3);
        c.Bool.MustNot.Should().HaveCount(1);
    });

一个更复杂的栗子

term && term && term && !term && +term && +term

依然会生成下面这个结构的单个 bool 查询

bool
|___must
|   |___term
|   |___term
|   |___term
|
|___must_not
|   |___term
|
|___filter
   |___term
   |___term
Assert(
    q => q.Query() && q.Query() && q.Query() && !q.Query() && +q.Query() && +q.Query(),
    Query && Query && Query && !Query && +Query && +Query,
    c =>
    {
        c.Bool.Must.Should().HaveCount(3);
        c.Bool.MustNot.Should().HaveCount(1);
        c.Bool.Filter.Should().HaveCount(2);
    });

你也可以将使用重载运算符的查询和真正的 bool 查询混合在一起

bool(must=term, term, term) && !term

仍然会合并为一个 bool 查询

Assert(
    q => q.Bool(b => b.Must(mq => mq.Query(), mq => mq.Query(), mq => mq.Query())) && !q.Query(),
    new BoolQuery { Must = new QueryContainer[] { Query, Query, Query } } && !Query,
    c =>
    {
        c.Bool.Must.Should().HaveCount(3);
        c.Bool.MustNot.Should().HaveCount(1);
    });

Combining queries with || or should clauses

就像之前的栗子，NEST 会把多个 should 或者 || 查询合并成一个包含多个 should 子句的 bool 查询。

总而言之，这个

term || term || term

会变成

bool
|___should
   |___term
   |___term
   |___term

但是，bool 查询不会完全遵循你从编程语言所期望的布尔逻辑

term1 && (term2 || term3 || term4)

不会变成

bool
|___must
|   |___term1
|
|___should
   |___term2
   |___term3
   |___term4

为什么会这样？当一个 bool 查询中只包含 should 子句时，至少会匹配一个。但是，当这个 bool 查询还包含一个 must 子句时，应该将 should 子句当作一个 boost 因子，这意味着他们都不是必需匹配的。但是如果匹配，文档的相关性评分会得到提高，从而在结果中显示更高的值。should 子句的行为会因为 must 的存在而发生改变。

因此，再看看前面那个示例，你只能得到包含 term1 的结果。这显然不是使用运算符重载的目的。

为此，NEST 将之前的查询重写成了：

bool
|___must
   |___term1
   |___bool
       |___should
           |___term2
           |___term3
           |___term4

Assert(
    q => q.Query() && (q.Query() || q.Query() || q.Query()),
    Query && (Query || Query || Query),
    c =>
    {
        c.Bool.Must.Should().HaveCount(2);
        var lastMustClause = (IQueryContainer)c.Bool.Must.Last();
        lastMustClause.Should().NotBeNull();
        lastMustClause.Bool.Should().NotBeNull();
        lastMustClause.Bool.Should.Should().HaveCount(3);
    });

添加圆括号，强制改变运算顺序

在构建搜索查询时，使用 should 子句作为 boost 因子可能是一个非常强大的构造方式。另外需要记住，你可以将实际的 bool 查询和 NEST 的重载运算符混合使用

还有一个微妙的情况，NEST 不会盲目地合并两个只包含 should 子句的 bool 查询。考虑下面这个查询

bool(should=term1, term2, term3, term4, minimum_should_match=2) || term5 || term6

如果 NEST 确定二元 || 运算符两边的查询只包含 should 子句，并把它们合并在了一起。这将给第一个 bool 查询中的 minimum_should_match 参数赋予不同的含义。将其改写为包含 5 个 should 子句的 bool 查询会破坏原始查询的语义，因为只匹配了 term5 或者 term6 的文档也应该被命中。

Assert(
    q => q.Bool(b => b
        .Should(mq => mq.Query(), mq => mq.Query(), mq => mq.Query(), mq => mq.Query())
        .MinimumShouldMatch(2)
        )
         || !q.Query() || q.Query(),
    new BoolQuery
    {
        Should = new QueryContainer[] { Query, Query, Query, Query },
        MinimumShouldMatch = 2
    } || !Query || Query,
    c =>
    {
        c.Bool.Should.Should().HaveCount(3);
        var nestedBool = c.Bool.Should.First() as IQueryContainer;
        nestedBool.Bool.Should.Should().HaveCount(4);
    });

Locked bool queries

如果设置了任何一个查询元数据，NEST 将不会合并 bool 查询。举个栗子，如果设置了 boost 或者 name ，NEST 会视其为已被锁定。

在这里，我们演示两个锁定的 bool 查询

Assert(
    q => q.Bool(b => b.Name("leftBool").Should(mq => mq.Query()))
         || q.Bool(b => b.Name("rightBool").Should(mq => mq.Query())),
    new BoolQuery { Name = "leftBool", Should = new QueryContainer[] { Query } }
    || new BoolQuery { Name = "rightBool", Should = new QueryContainer[] { Query } },
    c => AssertDoesNotJoinOntoLockedBool(c, "leftBool"));

锁定右边的查询

Assert(
    q => q.Bool(b => b.Should(mq => mq.Query()))
         || q.Bool(b => b.Name("rightBool").Should(mq => mq.Query())),
    new BoolQuery { Should = new QueryContainer[] { Query } }
    || new BoolQuery { Name = "rightBool", Should = new QueryContainer[] { Query } },
    c => AssertDoesNotJoinOntoLockedBool(c, "rightBool"));

锁定左边的查询

Assert(
    q => q.Bool(b => b.Name("leftBool").Should(mq => mq.Query()))
         || q.Bool(b => b.Should(mq => mq.Query())),
    new BoolQuery { Name = "leftBool", Should = new QueryContainer[] { Query } }
    || new BoolQuery { Should = new QueryContainer[] { Query } },
    c => AssertDoesNotJoinOntoLockedBool(c, "leftBool"));

Performance considerations

如果你需要使用 bool DSL 组合多个查询，请考虑一下内容。

你可以在循环中使用按位赋值来将多个查询合并为一个更大的查询。

本例中，我们使用 &= 赋值运算符创建一个含有 1000 个 must 子句的 bool 查询。

var c = new QueryContainer();
var q = new TermQuery { Field = "x", Value = "x" };

for (var i = 0; i < 1000; i++)
{
    c &= q;
}
|     Median|     StdDev|       Gen 0|  Gen 1|  Gen 2|  Bytes Allocated/Op
|  1.8507 ms|  0.1878 ms|    1,793.00|  21.00|      -|        1.872.672,28

可以看到，因为每次迭代我们都需要重新评估 bool 查询的合并能力，所以导致了大量的分配的产生。

由于我们事先已经知道了 bool 查询的形状，所以下面这个栗子要快的多

QueryContainer q = new TermQuery { Field = "x", Value = "x" };
var x = Enumerable.Range(0, 1000).Select(f => q).ToArray();
var boolQuery = new BoolQuery
{
    Must = x
};
|      Median|     StdDev|   Gen 0|  Gen 1|  Gen 2|  Bytes Allocated/Op
|  31.4610 μs|  0.9495 μs|  439.00|      -|      -|            7.912,95

在性能和分配上的下降是巨大的！

如果你使用的是 NEST 2.4.6 之前的版本，通过循环把很多 bool 查询分配给了一个更大的 bool 查询，客户端没有做好以最优化的方式合并结果的工作，并且在执行大约 2000 次迭代时可能会引发异常。这仅适用于按位分配许多 bool 查询，其他查询不受影响。

从 NEST 2.4.6 开始，你可以随意组合大量的 bool 查询。查阅 PR #2335 on github 了解更多信息。

转载于:https://www.cnblogs.com/WessonStar/p/8323875.html

diaobu4547
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
nestcloud-consul-starter:通过Consul快速使用NestCloud启动微服务应用
05-17
NestCloud NestCloud是微服务解决方案，由语言和框架编写。 安装 $ yarn install 依存关系 领事 运行应用 # development $ npm run start # watch mode $ npm run start:dev # production mode npm run start:prod 运行入门应用程序后，您可以在浏览器中访问以下网址： http：// localhost：3000 / github http：// localhost：3000 / proxy / github 保持联系 作者-NestCloud 执照 Nest已获得MIT许可。
nestjs入门（controller，service，module）
qq_40816649的博客
09-05 2266
通过项目目录初步认识nestjs以及命令创建相关的文件目录
Nestjs配置服务，配置Cookie和Session
Wang的专栏
07-02 1286
内置服务在我们生成模板项目的时候，已经有一个服务了：app.service.ts 这个服务其实是一个类，是一个被@Injectable装饰器装饰的类，在app.module.ts中引入并配置如果哪里用到这个服务，就在哪里注入，比如在app.controller.ts中去调用服务里面的方法 创建服务开发模板结构化配置1 ） cookie的初步使用对用户信息进行标识，让用户多个页面信息共享，这时候我们就要基于cookie和session来处理Nestjs默认使用express的HTTP配置时，我们可以安
Nestjs微服务
STImuLaTE_08的博客
04-24 972
这里我们有两种方式与微服务通信,this.client.send和this.client.emit,前者是通过请求-响应的方式,后者是通过事件驱动的方式,这两个的区别是,当我们需要有响应的时候,我们采用send方法,其对应微服务controller中的@MessagePattern,而emit方法表示我们要触发什么事件,对应@EventPattern,而后者通常不需要响应的返回值,只起到通知的作用.如果微服务模块不在本机上,还需要指定微服务模块的host,这样才能准确定位微服务模块的位置并成功与其通信。
微服务管家：NestJS 如何使用服务发现 Consul 实现高效的微服务节点管理
最新发布
乐闻世界
01-05 1287
在微服务架构中，服务发现是一项基础且关键的功能，它允许服务实例在网络中被动态发现。Consul 是一种服务网格解决方案，提供了服务发现、运行状况检查，过去和现代应用程序的连接等功能。本教程将向您展示如何在 NestJS 框架中集成 Consul 实现服务发现的能力。Consul 是由 HashiCorp 公司开发的一种服务网格解决方案，它提供完整的服务网格特性，并且可以在任何运行您的应用程序的环境中运行。服务发现。
nest-router：用于Nestjs框架的路由器模块
02-06
巢状路由器 :vertical_traffic_light: 框架的路由器模块 快速概述 RouterModule可帮助您组织路由并...npm install nest-router --save 要么 yarn add nest-router 建立 看看设置起来有多容易。 ... //imports con
nest-console:在您的NestJS应用程序中创建漂亮的CLI命令
05-11
npm install @squareboat/nest-console 或者 yarn add @squareboat/nest-console 入门 复制cli文件后，您需要打开cli文件并更改在createApplicationContext方法中传递的模块。 如果您遵循nest命令创建的默认项目...
nest-api
03-22
一个渐进式的框架，用于构建高效且可扩展的服务器端应用程序。...Nest是MIT许可的开源项目。得益于赞助商和出色支持者的支持，它可以发展壮大。如果您想加入他们，请。 保持联系 作者 网站-https: 执照 Nest已。
nest-puppeteer：Nest.js的Puppeteer（Headless Chrome）提供程序
02-12
安装在您现有的基于NestJS的项目中： npm install nest-puppeteer puppeteernpm install -D @types/puppeteer用法总体而言，它的工作方式与NestJS文档中介绍的任何可注射模块非常相似。 您可能还想参考这些文档-如果...
canvas-nest-react.js
01-10
见http://blog.csdn.net/carllucasyu/article/details/79022775
nestjs-console：一个nestjs模块，可为您的应用程序提供cli
02-02
是提供cli的模块。 模块的即用型服务类，提供使用命令注册命令和子命令的方法 为什么 nestjs框架缺少访问应用程序上下文的CLI。 常见用例：无头应用程序，cront任务，导出数据等... 提供了一种将cli命令和子命令绑定到提供者方法的方法。 这个怎么运作 控制台服务像经典的入口点一样，是一个独立的进程，它将初始化一个NestApplicationContext（无头）而不是一个NestApplication。 控制台服务将在容器内部访问。 Bootstrap（入口点，例如console.ts）由cli调用。 创建一个无头的嵌套应用应用程序内的任何模块都可以使用带nestjs-console创建命令和子命令 nestjs-console调用命令 指挥官会做剩下的。 npm install commander nestjs-console # or unig yarn yarn add commander nestjs-console 注意：对于<5>> 5.0.0的指挥官，请使用nestjs-console
python 布尔操作实现代码
01-20
和别的语言布尔类型定义1为真，0为假不同，python定义的真假比较多。 先说下假吧： false,none,0,””,{},[],() 而真的话，只要和上面的相反就行，比如上面是false,那真为true,[]空列表为假，不为空的列表为真。明白了这些。我们就可以用到python判断语句 如果你要把别的类型转换为bool类型的话，可以通过内置方法bool方法来进行转换。 您可能感兴趣的文章:python3中int（整型）的使用教程用Python将IP地址在整型和字符串之间轻松转换浅析Python 中整型对象存储的位置浅谈Python 中整型对象的
初识nest.js的controller(入门)
qq_63204040的博客
05-23 546
入门级controller以及部分装饰器用法
Elastic Search NEST研究(四)-NEST客户端在WebApi项目中的使用
lucyliang01的博客
02-04 693
NEST客户端在WebApi项目中的使用NEST客户端在WebApi项目中的使用创建web api项目在nuget中找到NEST依赖，并且安装目前版本7.10.1创建 ESHelper帮助类文件配置链接使用attribute自动映射创建映射创建或者修改单个文档批量创建文档批量删除全文检索ESHelper.cs代码ESController.cs代码 NEST客户端在WebApi项目中的使用 NEST是elastic search为.net 提供的高级客户端依赖组件。 这里我们会建一个web api2项目，进行
信息检索（基础知识二）—— 布尔检索模型
gegezaoshanghao的博客
11-02 2898
布尔检索模型 参照课堂所讲示例，利用构建的词项文档关联矩阵进行布尔检索，要求分别针对AND，OR和NOT进行检索，并分别给出实际检索案例。参照课堂所讲案例，利用构建的倒排索引进行布尔检索，支持AND操作，并给出实际检索案例。
使用Elasticsearch和C＃理解和实现CRUD APP的初学者教程——第2部分
寒冰屋的专栏
11-11 493
目录 介绍 创建一个演示应用 通过NEST与Elastic连接 第1组（索引、更新和删除） 第2组（标准查询） 第4组（范围查询） 第5组（聚合） 求和 平均 计数 最小/最大 结论 下载样本-17.9 MB 介绍 在第一部分中，我们学习了如何设置、配置和运行一堆Elastic语句。现在是时候将其转换为C＃完全可操作的CRUD应用程序了。让我们完成它。 创建一个演示应用 第一步，创建一个新的Windows窗体解决方案。可以从这里下载，它看起来像这样： 用红色突出显示的参
nestjs 多对多查询 多条件查询
zhuhui184的专栏
03-13 2597
多一对多的是其中A含有B的多个实例的关系，和B包含A.让我们以实例的多个实例Question和Category实体。问题可以有多个类别，每个类别可以有多个问题。 @JoinTable()@ManyToMany关系所需。您必须@JoinTable放任关系的（拥有）一方。 本示例将产生以下表格： import {Entity, PrimaryGeneratedColumn, Column}...
布尔检索模型的Java实现_使用Lucene实现一个简单的布尔搜索功能
weixin_42134054的博客
02-27 592
什么是luceneLucene是apache软件基金会jakarta项目组的一个子项目，是一个开放源代码的全文检索引擎工具包，但它不是一个完整的全文检索引擎，而是一个全文检索引擎的架构，提供了完整的查询引擎和索引引擎，部分文本分析引擎(英文与德文两种西方语言)。Lucene是一个全文搜索框架，而不是应用产品。因此它并不像www.baidu.com 或者google Desktop那么拿来就能用，它...
ElasticSearch7学习笔记之布尔查询
四国棋客
01-25 2185
文章目录基本正向匹配负向匹配嵌套布尔查询单字符串查询should查询dis_max查询单字符串多字段查询最佳字段多数字段混合字段中文和多语言分词检索中文分词拼音分词器hanlp分词英文精确分词 基本 一个布尔查询是一个或多个查询字句的组合，总共有四种子句，其中两个会影响算分，两个个不影响 正向匹配 子句顺序不重要，但如果没有must子句，那么should子句中必须至少有一项匹配。 示例如下，先插入数据： POST /products/_bulk { "index": { "_id": 1 }} { "pr
nest-admin
08-19
Nest Admin 是一个基于 Nest.js 和 Angular 的开源后台管理系统框架。Nest.js 是一个用于构建高效、可扩展的服务器端应用程序的框架，而 Angular 则是一个用于构建现代化 Web 应用程序的框架。Nest Admin 提供了一套...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值