honeymoose
/
OpenSearch
mirror of https://github.com/honeymoose/OpenSearch.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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.
This commit is contained in:
Bogdan Pintea 2020-11-26 11:43:40 +01:00 committed by GitHub
parent b3811d2fc2
commit 64ddf0834e
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
4 changed files with 113 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
docs/reference/release-notes/7.10.asciidoc
View File

@ -3,6 +3,19 @@
Also see <<breaking-changes-7.10,Breaking changes in 7.10>>.
[[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

26
docs/reference/release-notes/7.7.asciidoc
View File

@ -3,6 +3,19 @@
Also see <<breaking-changes-7.7,Breaking changes in 7.7>>.
[[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 <<breaking-changes-7.7,Breaking changes in 7.7>>.
[[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

26
docs/reference/release-notes/7.8.asciidoc
View File

@ -3,6 +3,19 @@
Also see <<breaking-changes-7.8,Breaking changes in 7.8>>.
[[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 <<breaking-changes-7.8,Breaking changes in 7.8>>.
[[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

48
docs/reference/release-notes/7.9.asciidoc
View File

@ -3,6 +3,19 @@
Also see <<breaking-changes-7.9,Breaking changes in 7.9>>.
[[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 <<breaking-changes-7.9,Breaking changes in 7.9>>.
[[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 <<breaking-changes-7.9,Breaking changes in 7.9>>.
[[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