pg.ddx.io pgsql-committers@postgresql.org mailing list archivehelp / color / mirror / Atom feed
pgsql: Fix parsing of ignored operators in websearch_to_tsquery(). 6+ messages / 1 participants [nested] [flat]
* pgsql: Fix parsing of ignored operators in websearch_to_tsquery(). @ 2024-06-14 00:35 Tom Lane <tgl@sss.pgh.pa.us> 0 siblings, 0 replies; 6+ messages in thread From: Tom Lane @ 2024-06-14 00:35 UTC (permalink / raw) To: pgsql-committers@lists.postgresql.org Fix parsing of ignored operators in websearch_to_tsquery(). The manual says clearly that punctuation in the input of websearch_to_tsquery() is ignored, except for the special cases of dashes and quotes. However, this failed for cases like "(foo bar) or something", or in general an ISOPERATOR character in front of the "or". We'd switch back to WAITOPERAND state, then ignore the operator character while remaining in that state, and then reach the "or" in WAITOPERAND state which (intentionally) makes us treat it as data. The fix is simple enough: if we see an ISOPERATOR character while in WAITOPERATOR state, we have to skip it while staying in that state. (We don't need to worry about other punctuation characters: those will be consumed as though they were words, but then rejected by lexizing.) In v14 and up (since commit eb086056f) we can simplify the code a bit more too, because there is no longer a reason for the WAITOPERAND state to distinguish between quoted and unquoted operands. Per bug #18479 from Manos Emmanouilidis. Back-patch to all supported branches. Discussion: https://postgr.es/m/18479-d9b46e2fc242c33e@postgresql.org Branch ------ REL_13_STABLE Details ------- https://git.postgresql.org/pg/commitdiff/c7de5a654567ffbd0eef1d6d2fb8d3fa2b5c5dee Modified Files -------------- src/backend/utils/adt/tsquery.c | 8 +++++++- src/test/regress/expected/tsearch.out | 7 +++++++ src/test/regress/sql/tsearch.sql | 3 +++ 3 files changed, 17 insertions(+), 1 deletion(-) ^ permalink raw reply [nested|flat] 6+ messages in thread
* pgsql: Fix parsing of ignored operators in websearch_to_tsquery(). @ 2024-06-14 00:35 Tom Lane <tgl@sss.pgh.pa.us> 0 siblings, 0 replies; 6+ messages in thread From: Tom Lane @ 2024-06-14 00:35 UTC (permalink / raw) To: pgsql-committers@lists.postgresql.org Fix parsing of ignored operators in websearch_to_tsquery(). The manual says clearly that punctuation in the input of websearch_to_tsquery() is ignored, except for the special cases of dashes and quotes. However, this failed for cases like "(foo bar) or something", or in general an ISOPERATOR character in front of the "or". We'd switch back to WAITOPERAND state, then ignore the operator character while remaining in that state, and then reach the "or" in WAITOPERAND state which (intentionally) makes us treat it as data. The fix is simple enough: if we see an ISOPERATOR character while in WAITOPERATOR state, we have to skip it while staying in that state. (We don't need to worry about other punctuation characters: those will be consumed as though they were words, but then rejected by lexizing.) In v14 and up (since commit eb086056f) we can simplify the code a bit more too, because there is no longer a reason for the WAITOPERAND state to distinguish between quoted and unquoted operands. Per bug #18479 from Manos Emmanouilidis. Back-patch to all supported branches. Discussion: https://postgr.es/m/18479-d9b46e2fc242c33e@postgresql.org Branch ------ REL_16_STABLE Details ------- https://git.postgresql.org/pg/commitdiff/086ecd12bc1c27054ded1eeea5329e84e3f72c97 Modified Files -------------- src/backend/utils/adt/tsquery.c | 22 +++++++++------------- src/test/regress/expected/tsearch.out | 7 +++++++ src/test/regress/sql/tsearch.sql | 3 +++ 3 files changed, 19 insertions(+), 13 deletions(-) ^ permalink raw reply [nested|flat] 6+ messages in thread
* pgsql: Fix parsing of ignored operators in websearch_to_tsquery(). @ 2024-06-14 00:35 Tom Lane <tgl@sss.pgh.pa.us> 0 siblings, 0 replies; 6+ messages in thread From: Tom Lane @ 2024-06-14 00:35 UTC (permalink / raw) To: pgsql-committers@lists.postgresql.org Fix parsing of ignored operators in websearch_to_tsquery(). The manual says clearly that punctuation in the input of websearch_to_tsquery() is ignored, except for the special cases of dashes and quotes. However, this failed for cases like "(foo bar) or something", or in general an ISOPERATOR character in front of the "or". We'd switch back to WAITOPERAND state, then ignore the operator character while remaining in that state, and then reach the "or" in WAITOPERAND state which (intentionally) makes us treat it as data. The fix is simple enough: if we see an ISOPERATOR character while in WAITOPERATOR state, we have to skip it while staying in that state. (We don't need to worry about other punctuation characters: those will be consumed as though they were words, but then rejected by lexizing.) In v14 and up (since commit eb086056f) we can simplify the code a bit more too, because there is no longer a reason for the WAITOPERAND state to distinguish between quoted and unquoted operands. Per bug #18479 from Manos Emmanouilidis. Back-patch to all supported branches. Discussion: https://postgr.es/m/18479-d9b46e2fc242c33e@postgresql.org Branch ------ master Details ------- https://git.postgresql.org/pg/commitdiff/56a8296212b68267dc2bddeb1fb40a893b1aadb3 Modified Files -------------- src/backend/utils/adt/tsquery.c | 22 +++++++++------------- src/test/regress/expected/tsearch.out | 7 +++++++ src/test/regress/sql/tsearch.sql | 3 +++ 3 files changed, 19 insertions(+), 13 deletions(-) ^ permalink raw reply [nested|flat] 6+ messages in thread
* pgsql: Fix parsing of ignored operators in websearch_to_tsquery(). @ 2024-06-14 00:35 Tom Lane <tgl@sss.pgh.pa.us> 0 siblings, 0 replies; 6+ messages in thread From: Tom Lane @ 2024-06-14 00:35 UTC (permalink / raw) To: pgsql-committers@lists.postgresql.org Fix parsing of ignored operators in websearch_to_tsquery(). The manual says clearly that punctuation in the input of websearch_to_tsquery() is ignored, except for the special cases of dashes and quotes. However, this failed for cases like "(foo bar) or something", or in general an ISOPERATOR character in front of the "or". We'd switch back to WAITOPERAND state, then ignore the operator character while remaining in that state, and then reach the "or" in WAITOPERAND state which (intentionally) makes us treat it as data. The fix is simple enough: if we see an ISOPERATOR character while in WAITOPERATOR state, we have to skip it while staying in that state. (We don't need to worry about other punctuation characters: those will be consumed as though they were words, but then rejected by lexizing.) In v14 and up (since commit eb086056f) we can simplify the code a bit more too, because there is no longer a reason for the WAITOPERAND state to distinguish between quoted and unquoted operands. Per bug #18479 from Manos Emmanouilidis. Back-patch to all supported branches. Discussion: https://postgr.es/m/18479-d9b46e2fc242c33e@postgresql.org Branch ------ REL_15_STABLE Details ------- https://git.postgresql.org/pg/commitdiff/df95c1ec0e988f4eb7d67fd7541501c894dfe082 Modified Files -------------- src/backend/utils/adt/tsquery.c | 22 +++++++++------------- src/test/regress/expected/tsearch.out | 7 +++++++ src/test/regress/sql/tsearch.sql | 3 +++ 3 files changed, 19 insertions(+), 13 deletions(-) ^ permalink raw reply [nested|flat] 6+ messages in thread
* pgsql: Fix parsing of ignored operators in websearch_to_tsquery(). @ 2024-06-14 00:35 Tom Lane <tgl@sss.pgh.pa.us> 0 siblings, 0 replies; 6+ messages in thread From: Tom Lane @ 2024-06-14 00:35 UTC (permalink / raw) To: pgsql-committers@lists.postgresql.org Fix parsing of ignored operators in websearch_to_tsquery(). The manual says clearly that punctuation in the input of websearch_to_tsquery() is ignored, except for the special cases of dashes and quotes. However, this failed for cases like "(foo bar) or something", or in general an ISOPERATOR character in front of the "or". We'd switch back to WAITOPERAND state, then ignore the operator character while remaining in that state, and then reach the "or" in WAITOPERAND state which (intentionally) makes us treat it as data. The fix is simple enough: if we see an ISOPERATOR character while in WAITOPERATOR state, we have to skip it while staying in that state. (We don't need to worry about other punctuation characters: those will be consumed as though they were words, but then rejected by lexizing.) In v14 and up (since commit eb086056f) we can simplify the code a bit more too, because there is no longer a reason for the WAITOPERAND state to distinguish between quoted and unquoted operands. Per bug #18479 from Manos Emmanouilidis. Back-patch to all supported branches. Discussion: https://postgr.es/m/18479-d9b46e2fc242c33e@postgresql.org Branch ------ REL_12_STABLE Details ------- https://git.postgresql.org/pg/commitdiff/5e63a6f434152b34795e02f534615af2174707f7 Modified Files -------------- src/backend/utils/adt/tsquery.c | 8 +++++++- src/test/regress/expected/tsearch.out | 7 +++++++ src/test/regress/sql/tsearch.sql | 3 +++ 3 files changed, 17 insertions(+), 1 deletion(-) ^ permalink raw reply [nested|flat] 6+ messages in thread
* pgsql: Fix parsing of ignored operators in websearch_to_tsquery(). @ 2024-06-14 00:35 Tom Lane <tgl@sss.pgh.pa.us> 0 siblings, 0 replies; 6+ messages in thread From: Tom Lane @ 2024-06-14 00:35 UTC (permalink / raw) To: pgsql-committers@lists.postgresql.org Fix parsing of ignored operators in websearch_to_tsquery(). The manual says clearly that punctuation in the input of websearch_to_tsquery() is ignored, except for the special cases of dashes and quotes. However, this failed for cases like "(foo bar) or something", or in general an ISOPERATOR character in front of the "or". We'd switch back to WAITOPERAND state, then ignore the operator character while remaining in that state, and then reach the "or" in WAITOPERAND state which (intentionally) makes us treat it as data. The fix is simple enough: if we see an ISOPERATOR character while in WAITOPERATOR state, we have to skip it while staying in that state. (We don't need to worry about other punctuation characters: those will be consumed as though they were words, but then rejected by lexizing.) In v14 and up (since commit eb086056f) we can simplify the code a bit more too, because there is no longer a reason for the WAITOPERAND state to distinguish between quoted and unquoted operands. Per bug #18479 from Manos Emmanouilidis. Back-patch to all supported branches. Discussion: https://postgr.es/m/18479-d9b46e2fc242c33e@postgresql.org Branch ------ REL_14_STABLE Details ------- https://git.postgresql.org/pg/commitdiff/5912bf77c526fdb8cfc9bbb56a509a152c6a3632 Modified Files -------------- src/backend/utils/adt/tsquery.c | 22 +++++++++------------- src/test/regress/expected/tsearch.out | 7 +++++++ src/test/regress/sql/tsearch.sql | 3 +++ 3 files changed, 19 insertions(+), 13 deletions(-) ^ permalink raw reply [nested|flat] 6+ messages in thread
end of thread, other threads:[~2024-06-14 00:35 UTC | newest] Thread overview: 6+ messages (download: mbox mbox.gz follow: Atom feed) -- links below jump to the message on this page -- 2024-06-14 00:35 pgsql: Fix parsing of ignored operators in websearch_to_tsquery(). Tom Lane <tgl@sss.pgh.pa.us> 2024-06-14 00:35 pgsql: Fix parsing of ignored operators in websearch_to_tsquery(). Tom Lane <tgl@sss.pgh.pa.us> 2024-06-14 00:35 pgsql: Fix parsing of ignored operators in websearch_to_tsquery(). Tom Lane <tgl@sss.pgh.pa.us> 2024-06-14 00:35 pgsql: Fix parsing of ignored operators in websearch_to_tsquery(). Tom Lane <tgl@sss.pgh.pa.us> 2024-06-14 00:35 pgsql: Fix parsing of ignored operators in websearch_to_tsquery(). Tom Lane <tgl@sss.pgh.pa.us> 2024-06-14 00:35 pgsql: Fix parsing of ignored operators in websearch_to_tsquery(). Tom Lane <tgl@sss.pgh.pa.us>
This inbox is served by DDX for PostgreSQL; see mirroring instructions for how to clone and mirror all data and code used for this inbox