From 64ddf0834ea0c80f9997bcfbb159c8ce48b448b2 Mon Sep 17 00:00:00 2001 From: Bogdan Pintea Date: Thu, 26 Nov 2020 11:43:40 +0100 Subject: [PATCH] Docs: add known issue 65488 - SQL ignoring non-eq (#65492) * Docs: add known issue 65488 - SQL ignoring non-eq Add description of the #65488 known issue in release notes. --- docs/reference/release-notes/7.10.asciidoc | 13 ++++++ docs/reference/release-notes/7.7.asciidoc | 26 ++++++++++++ docs/reference/release-notes/7.8.asciidoc | 26 ++++++++++++ docs/reference/release-notes/7.9.asciidoc | 48 ++++++++++++++++++++++ 4 files changed, 113 insertions(+) diff --git a/docs/reference/release-notes/7.10.asciidoc b/docs/reference/release-notes/7.10.asciidoc index 7c9865951ed..8e404c5bbe7 100644 --- a/docs/reference/release-notes/7.10.asciidoc +++ b/docs/reference/release-notes/7.10.asciidoc @@ -3,6 +3,19 @@ Also see <>. +[[known-issues-7.10.0]] +[discrete] +=== Known issues + +* SQL: If a `WHERE` clause contains at least two relational operators joined by +`AND`, of which one is a comparison (`<=`, `<`, `>=`, `>`) and another one is +an inequality (`!=`, `<>`), both against literals or foldable expressions, the +inequality will be ignored. The workaround is to substitute the inequality +with a `NOT IN` operator. ++ +We have fixed this issue in {es} 7.10.1 and later versions. For more details, +see {es-issue}65488[#65488]. + [[breaking-7.10.0]] [float] === Breaking changes diff --git a/docs/reference/release-notes/7.7.asciidoc b/docs/reference/release-notes/7.7.asciidoc index adff17fff64..de7ec59aa46 100644 --- a/docs/reference/release-notes/7.7.asciidoc +++ b/docs/reference/release-notes/7.7.asciidoc @@ -3,6 +3,19 @@ Also see <>. +[[known-issues-7.7.1]] +[discrete] +=== Known issues + +* SQL: If a `WHERE` clause contains at least two relational operators joined by +`AND`, of which one is a comparison (`<=`, `<`, `>=`, `>`) and another one is +an inequality (`!=`, `<>`), both against literals or foldable expressions, the +inequality will be ignored. The workaround is to substitute the inequality +with a `NOT IN` operator. ++ +We have fixed this issue in {es} 7.10.1 and later versions. For more details, +see {es-issue}65488[#65488]. + [[enhancement-7.7.1]] [discrete] === Enhancements @@ -135,6 +148,19 @@ SQL:: Also see <>. +[[known-issues-7.7.0]] +[discrete] +=== Known issues + +* SQL: If a `WHERE` clause contains at least two relational operators joined by +`AND`, of which one is a comparison (`<=`, `<`, `>=`, `>`) and another one is +an inequality (`!=`, `<>`), both against literals or foldable expressions, the +inequality will be ignored. The workaround is to substitute the inequality +with a `NOT IN` operator. ++ +We have fixed this issue in {es} 7.10.1 and later versions. For more details, +see {es-issue}65488[#65488]. + [[breaking-7.7.0]] [discrete] === Breaking changes diff --git a/docs/reference/release-notes/7.8.asciidoc b/docs/reference/release-notes/7.8.asciidoc index 671d43236c2..71e15b86368 100644 --- a/docs/reference/release-notes/7.8.asciidoc +++ b/docs/reference/release-notes/7.8.asciidoc @@ -3,6 +3,19 @@ Also see <>. +[[known-issues-7.8.1]] +[discrete] +=== Known issues + +* SQL: If a `WHERE` clause contains at least two relational operators joined by +`AND`, of which one is a comparison (`<=`, `<`, `>=`, `>`) and another one is +an inequality (`!=`, `<>`), both against literals or foldable expressions, the +inequality will be ignored. The workaround is to substitute the inequality +with a `NOT IN` operator. ++ +We have fixed this issue in {es} 7.10.1 and later versions. For more details, +see {es-issue}65488[#65488]. + [[breaking-7.8.1]] [discrete] === Breaking changes @@ -147,6 +160,19 @@ Infra/Core:: Also see <>. +[[known-issues-7.8.0]] +[discrete] +=== Known issues + +* SQL: If a `WHERE` clause contains at least two relational operators joined by +`AND`, of which one is a comparison (`<=`, `<`, `>=`, `>`) and another one is +an inequality (`!=`, `<>`), both against literals or foldable expressions, the +inequality will be ignored. The workaround is to substitute the inequality +with a `NOT IN` operator. ++ +We have fixed this issue in {es} 7.10.1 and later versions. For more details, +see {es-issue}65488[#65488]. + [[breaking-7.8.0]] [discrete] === Breaking changes diff --git a/docs/reference/release-notes/7.9.asciidoc b/docs/reference/release-notes/7.9.asciidoc index b7cd4bbb8de..973a562b615 100644 --- a/docs/reference/release-notes/7.9.asciidoc +++ b/docs/reference/release-notes/7.9.asciidoc @@ -3,6 +3,19 @@ Also see <>. +[[known-issues-7.9.3]] +[discrete] +=== Known issues + +* SQL: If a `WHERE` clause contains at least two relational operators joined by +`AND`, of which one is a comparison (`<=`, `<`, `>=`, `>`) and another one is +an inequality (`!=`, `<>`), both against literals or foldable expressions, the +inequality will be ignored. The workaround is to substitute the inequality +with a `NOT IN` operator. ++ +We have fixed this issue in {es} 7.10.1 and later versions. For more details, +see {es-issue}65488[#65488]. + [[bug-7.9.3]] [float] === Bug fixes @@ -68,6 +81,19 @@ Infra/Packaging:: Also see <>. +[[known-issues-7.9.2]] +[discrete] +=== Known issues + +* SQL: If a `WHERE` clause contains at least two relational operators joined by +`AND`, of which one is a comparison (`<=`, `<`, `>=`, `>`) and another one is +an inequality (`!=`, `<>`), both against literals or foldable expressions, the +inequality will be ignored. The workaround is to substitute the inequality +with a `NOT IN` operator. ++ +We have fixed this issue in {es} 7.10.1 and later versions. For more details, +see {es-issue}65488[#65488]. + [[deprecation-7.9.2]] [float] === Deprecations @@ -164,6 +190,19 @@ Infra/Packaging:: Also see <>. +[[known-issues-7.9.1]] +[discrete] +=== Known issues + +* SQL: If a `WHERE` clause contains at least two relational operators joined by +`AND`, of which one is a comparison (`<=`, `<`, `>=`, `>`) and another one is +an inequality (`!=`, `<>`), both against literals or foldable expressions, the +inequality will be ignored. The workaround is to substitute the inequality +with a `NOT IN` operator. ++ +We have fixed this issue in {es} 7.10.1 and later versions. For more details, +see {es-issue}65488[#65488]. + [[feature-7.9.1]] [float] === New features @@ -312,6 +351,15 @@ Full details of the mitigations are in https://github.com/apache/lucene-solr/pull/1779[fix] in Lucene 8.6.2 to deliver in Elasticsearch 7.9.1 that will address this memory leak. +* SQL: If a `WHERE` clause contains at least two relational operators joined by +`AND`, of which one is a comparison (`<=`, `<`, `>=`, `>`) and another one is +an inequality (`!=`, `<>`), both against literals or foldable expressions, the +inequality will be ignored. The workaround is to substitute the inequality +with a `NOT IN` operator. ++ +We have fixed this issue in {es} 7.10.1 and later versions. For more details, +see {es-issue}65488[#65488]. + [[breaking-7.9.0]] [discrete] === Breaking changes