Case Conversion Fix for MB Chars

Here's small patch to fix case conversion problems for ILIKE and
(Oracle Compat.) lower/upper functions. (Related bug report is here:
http://archives.postgresql.org/pgsql-bugs/2005-10/msg00001.php)

In tests it succeeded for Turkish characters while using LATIN5
encoding. But when encoding is UNICODE it still doesn't work. (IMHO,
for latin-N encodings there will be no compatibility problems; for
Unicode, I've no idea.)

Regards.

Last minute edit:

On 11/26/05, Volkan YAZICI <volkan(dot)yazici(at)gmail(dot)com> wrote:
- In tests it succeeded for Turkish characters while using LATIN5
- encoding. But when encoding is UNICODE it still doesn't work. (IMHO,
- for latin-N encodings there will be no compatibility problems; for
- Unicode, I've no idea.)
+ In tests it succeeded for Turkish characters while using both
+ LATIN5 and UNICODE encodings. Furthermore, it shouldn't raise
+ any compatibility problems for LATIN-N encodings, but for
+ UNICODE, I don't have an exact idea.

Regards.

Volkan YAZICI <volkan(dot)yazici(at)gmail(dot)com> writes:
> Here's small patch to fix case conversion problems for ILIKE and
> (Oracle Compat.) lower/upper functions. (Related bug report is here:
> http://archives.postgresql.org/pgsql-bugs/2005-10/msg00001.php)

Doesn't this just move the failure cases around?

The really fundamental problem is that tolower/toupper don't work
on wchar_t.

regards, tom lane

On 11/27/05, Tom Lane <tgl(at)sss(dot)pgh(dot)pa(dot)us> wrote:
> Doesn't this just move the failure cases around?

I don't think so. I've tried to fix every tolower/toupper related
problem (depending on the MB characters) I found in the code. If
there's still a problem with them, it should be related with the
pg_wchar_tb concept in utils/mb/wchar.c (AFAIC, the last remaning part
about this case conversion mess is the one related with PQfnumber -
which needs a very different approach.)

> The really fundamental problem is that tolower/toupper don't work
> on wchar_t.

Yes, indeed. I agree with you to find a proper solution for character
set handling. But, IMHO, it's better to have a-patchy working system
instead of a not working one. Put yourself in our position, we're
trying to give enterprise solutions to our customers and ILIKE,
lower/upper doesn't work in the product that we support. We can work
with a small patch instead of waiting next releases for an exact
solution to the problem.

Regards.

[Sorry if the post is duplicated. But I don't receive and ACK from majordamo.]

On 11/27/05, Tom Lane <tgl(at)sss(dot)pgh(dot)pa(dot)us> wrote:
> Doesn't this just move the failure cases around?

I don't think so. I've tried to fix every tolower/toupper related
problem (depending on the MB characters) I found in the code. If
there's still a problem with them, it should be related with the
pg_wchar_tb concept in utils/mb/wchar.c (AFAIC, the last remaning part
about this case conversion mess is the one related with PQfnumber -
which needs a very different approach.)

> The really fundamental problem is that tolower/toupper don't work
> on wchar_t.

Yes, indeed. I agree with you to find a proper solution for character
set handling. But, IMHO, it's better to have a-patchy working system
instead of a not working one. Put yourself in our position, we're
trying to give enterprise solutions to our customers and ILIKE,
lower/upper doesn't work in the product that we support. We can work
with a small patch instead of waiting next releases for an exact
solution to the problem.

Regards.

[Sorry if the post is duplicated. But I don't receive and ACK from majordamo.]

On 11/27/05, Tom Lane <tgl(at)sss(dot)pgh(dot)pa(dot)us> wrote:
> Doesn't this just move the failure cases around?

I don't think so. I've tried to fix every tolower/toupper related
problem (depending on the MB characters) I found in the code. If
there's still a problem with them, it should be related with the
pg_wchar_tb concept in utils/mb/wchar.c (AFAIC, the last remaning part
about this case conversion mess is the one related with PQfnumber -
which needs a very different approach.)

> The really fundamental problem is that tolower/toupper don't work
> on wchar_t.

Yes, indeed. I agree with you to find a proper solution for character
set handling. But, IMHO, it's better to have a-patchy working system
instead of a not working one. Put yourself in our position, we're
trying to give enterprise solutions to our customers and ILIKE,
lower/upper doesn't work in the product that we support. We can work
with a small patch instead of waiting next releases for an exact
solution to the problem.

Volkan YAZICI <volkan(dot)yazici(at)gmail(dot)com> writes:
> On 11/27/05, Tom Lane <tgl(at)sss(dot)pgh(dot)pa(dot)us> wrote:
>> The really fundamental problem is that tolower/toupper don't work
>> on wchar_t.

> Yes, indeed. I agree with you to find a proper solution for character
> set handling. But, IMHO, it's better to have a-patchy working system
> instead of a not working one.

But you just agreed that it doesn't work.

It might be that there are degrees of not-working-ness here, but before
adopting a partial solution I would like to see some reasoning why it
won't make things worse for other people. I think that what you are
proposing could lead to arbitrarily bad behavior (up to and including
server crashes) depending on what libc's toupper/tolower functions are
coded to do with out-of-range inputs. Exactly what cases have you
tried, and on what platforms?

regards, tom lane

On 11/27/05, Tom Lane <tgl(at)sss(dot)pgh(dot)pa(dot)us> wrote:
> > Yes, indeed. I agree with you to find a proper solution for character
> > set handling. But, IMHO, it's better to have a-patchy working system
> > instead of a not working one.
>
> But you just agreed that it doesn't work.

You get me wrong. I tried to to say it works for latin5 and unicode.
When I look at the latin-n implementation of PostgreSQL, see that
there doesn't exist a far difference between 'em. So there shouldn't
be a problem with latin-n encodings. But, as I try to explain, I don't
have so much knowledge on unicode characters and cannot claim an exact
answer about it.

> It might be that there are degrees of not-working-ness here, but before
> adopting a partial solution I would like to see some reasoning why it
> won't make things worse for other people. I think that what you are
> proposing could lead to arbitrarily bad behavior (up to and including
> server crashes) depending on what libc's toupper/tolower functions are
> coded to do with out-of-range inputs.

Furthermore, I just used the methods already in the code. If it'll
cause any crashes in the server side, it won't be my fault. (Except
logical errors I made.)

> Exactly what cases have you tried, and on what platforms?

I don't have a buildfarm at home. Tests made on an i686 with a
2.6.12.5 kernel. Here's a short list of cases I tried with both latin5
and unicode charsets:
- lower/upper functions with Turkish characters.
- ILIKE matches with both lower and upper case Turkish characters.
(Above testes succeeded for non-Turkish characters too.)

Regards.

On 11/27/05, Volkan YAZICI <volkan(dot)yazici(at)gmail(dot)com> wrote:
> Tests made on an i686 with a
> 2.6.12.5 kernel. Here's a short list of cases I tried with both latin5
> and unicode charsets:
> - lower/upper functions with Turkish characters.
> - ILIKE matches with both lower and upper case Turkish characters.
> (Above testes succeeded for non-Turkish characters too.)

I read the above paragraph again and realized the out of usability of
it. Here's a modified one:

Test's made on a Debian GNU/Linux (stable) 3.1 by patching
src/backend/utils/adt/like.c (r1.62) and
src/backend/utils/adt/oracle_compat.c (r1.64) files. Related software
versions:
- gcc-3.3 [3.3.5-13]
- libc6-dev [2.3.2.ds1-22]
- locales [2.3.2.ds1-22]

Tried test cases using patched CVS HEAD:

[For Latin5]
$ usr/bin/initdb -D var/data
$ LANG="tr_TR.ISO-8859-9" usr/bin/postmaster -D var/data
$ usr/bin/createdb -E latin5 test_latin5
$ usr/bin/psql test_latin5
Welcome to psql 8.2devel, the PostgreSQL interactive terminal.

Type: \copyright for distribution terms
\h for help with SQL commands
\? for help with psql commands
\g or terminate with semicolon to execute query
\q to quit

test_latin5=# SHOW client_encoding;
client_encoding
-----------------
LATIN5
(1 row)

test_latin5=# SELECT upper('abcdefgğhıijklmnoöprsştuüvyz qwx 0123456789');
upper
-------------------------------------------
ABCDEFGĞHIİJKLMNOÖPRSŞTUÜVYZ QWX 0123456789
(1 row)

test_latin5=# SELECT
test_latin5-# lower('ABCDEFGĞHIİJKLMNOÖPRSŞTUÜVYZ QWX 0123456789');
lower
---------------------------------------------
abcdefgğhıijklmnoöprsştuüvyz qwx 0123456789
(1 row)

test_latin5=# BEGIN;
BEGIN
test_latin5=# CREATE TEMP TABLE t (v varchar);
CREATE TABLE
test_latin5=# COPY t FROM stdin;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> ı123
>> I123
>> i123
>> İ123
>> \.
test_latin5=# SELECT v FROM t;
v
------
ı123
I123
i123
İ123
(4 rows)

test_latin5=# SELECT v FROM t WHERE v ILIKE 'ı%';
v
------
ı123
I123
(2 rows)

test_latin5=# SELECT v FROM t WHERE v ILIKE 'I%';
v
------
ı123
I123
(2 rows)

test_latin5=# SELECT v FROM t WHERE v ILIKE 'i%';
v
------
i123
İ123
(2 rows)

test_latin5=# SELECT v FROM t WHERE v ILIKE 'İ%';
v
------
i123
İ123
(2 rows)

test_latin5=# ROLLBACK;
ROLLBACK

[For UNICODE]
Same steps as above with LANG="tr_TR.UTF-8" and database/client
encoding as UNICODE.

Hope this tests help.

Regards.

Where are we on this patch? Is it to be applied?

---------------------------------------------------------------------------

Volkan YAZICI wrote:
> On 11/27/05, Volkan YAZICI <volkan(dot)yazici(at)gmail(dot)com> wrote:
> > Tests made on an i686 with a
> > 2.6.12.5 kernel. Here's a short list of cases I tried with both latin5
> > and unicode charsets:
> > - lower/upper functions with Turkish characters.
> > - ILIKE matches with both lower and upper case Turkish characters.
> > (Above testes succeeded for non-Turkish characters too.)
>
> I read the above paragraph again and realized the out of usability of
> it. Here's a modified one:
>
> Test's made on a Debian GNU/Linux (stable) 3.1 by patching
> src/backend/utils/adt/like.c (r1.62) and
> src/backend/utils/adt/oracle_compat.c (r1.64) files. Related software
> versions:
> - gcc-3.3 [3.3.5-13]
> - libc6-dev [2.3.2.ds1-22]
> - locales [2.3.2.ds1-22]
>
> Tried test cases using patched CVS HEAD:
>
> [For Latin5]
> $ usr/bin/initdb -D var/data
> $ LANG="tr_TR.ISO-8859-9" usr/bin/postmaster -D var/data
> $ usr/bin/createdb -E latin5 test_latin5
> $ usr/bin/psql test_latin5
> Welcome to psql 8.2devel, the PostgreSQL interactive terminal.
>
> Type: \copyright for distribution terms
> \h for help with SQL commands
> \? for help with psql commands
> \g or terminate with semicolon to execute query
> \q to quit
>
> test_latin5=# SHOW client_encoding;
> client_encoding
> -----------------
> LATIN5
> (1 row)
>
> test_latin5=# SELECT upper('abcdefg?h?ijklmno?prs?tu?vyz qwx 0123456789');
> upper
> -------------------------------------------
> ABCDEFG?HI?JKLMNO?PRS?TU?VYZ QWX 0123456789
> (1 row)
>
> test_latin5=# SELECT
> test_latin5-# lower('ABCDEFG?HI?JKLMNO?PRS?TU?VYZ QWX 0123456789');
> lower
> ---------------------------------------------
> abcdefg?h?ijklmno?prs?tu?vyz qwx 0123456789
> (1 row)
>
> test_latin5=# BEGIN;
> BEGIN
> test_latin5=# CREATE TEMP TABLE t (v varchar);
> CREATE TABLE
> test_latin5=# COPY t FROM stdin;
> Enter data to be copied followed by a newline.
> End with a backslash and a period on a line by itself.
> >> ?123
> >> I123
> >> i123
> >> ?123
> >> \.
> test_latin5=# SELECT v FROM t;
> v
> ------
> ?123
> I123
> i123
> ?123
> (4 rows)
>
> test_latin5=# SELECT v FROM t WHERE v ILIKE '?%';
> v
> ------
> ?123
> I123
> (2 rows)
>
> test_latin5=# SELECT v FROM t WHERE v ILIKE 'I%';
> v
> ------
> ?123
> I123
> (2 rows)
>
> test_latin5=# SELECT v FROM t WHERE v ILIKE 'i%';
> v
> ------
> i123
> ?123
> (2 rows)
>
> test_latin5=# SELECT v FROM t WHERE v ILIKE '?%';
> v
> ------
> i123
> ?123
> (2 rows)
>
> test_latin5=# ROLLBACK;
> ROLLBACK
>
> [For UNICODE]
> Same steps as above with LANG="tr_TR.UTF-8" and database/client
> encoding as UNICODE.
>
> Hope this tests help.
>
>
> Regards.
>
> ---------------------------(end of broadcast)---------------------------
> TIP 6: explain analyze is your friend
>

--
Bruce Momjian | http://candle.pha.pa.us
pgman(at)candle(dot)pha(dot)pa(dot)us | (610) 359-1001
+ If your life is a hard drive, | 13 Roberts Road
+ Christ can be your backup. | Newtown Square, Pennsylvania 19073

Hi,

On Thu, 1 Dec 2005, Bruce Momjian wrote:

> Where are we on this patch? Is it to be applied?

The patch worked on FreeBSD 5.4-CURRENT. Maybe what Tom wants is more port
reports, hmm?

Volkan stated out the reasons that why we need this patch, I'll not repeat
it again.

Regards,
--
Devrim GUNDUZ
Kivi Bilişim Teknolojileri - http://www.kivi.com.tr
devrim~gunduz.org, devrim~PostgreSQL.org, devrim.gunduz~linux.org.tr
http://www.gunduz.org
>From pgsql-patches-owner(at)postgresql(dot)org Thu Dec 1 17:34:52 2005
X-Original-To: pgsql-patches-postgresql(dot)org(at)localhost(dot)postgresql(dot)org
Received: from localhost (av.hub.org [200.46.204.144])
by postgresql.org (Postfix) with ESMTP id D48B79DD6B6
for <pgsql-patches-postgresql(dot)org(at)localhost(dot)postgresql(dot)org>; Thu, 1 Dec 2005 17:34:50 -0400 (AST)
Received: from postgresql.org ([200.46.204.71])
by localhost (av.hub.org [200.46.204.144]) (amavisd-new, port 10024)
with ESMTP id 92049-09
for <pgsql-patches-postgresql(dot)org(at)localhost(dot)postgresql(dot)org>;
Thu, 1 Dec 2005 17:34:47 -0400 (AST)
X-Greylist: from auto-whitelisted by SQLgrey-
Received: from sss.pgh.pa.us (sss.pgh.pa.us [66.207.139.130])
by postgresql.org (Postfix) with ESMTP id 5B39B9DD64F
for <pgsql-patches(at)postgreSQL(dot)org>; Thu, 1 Dec 2005 17:34:47 -0400 (AST)
Received: from sss2.sss.pgh.pa.us (tgl(at)localhost [127.0.0.1])
by sss.pgh.pa.us (8.13.1/8.13.1) with ESMTP id jB1LYkFL017377;
Thu, 1 Dec 2005 16:34:46 -0500 (EST)
To: pgsql-patches(at)postgreSQL(dot)org
cc: Qingqing Zhou <zhouqq(at)cs(dot)toronto(dot)edu>
Subject: Re: Fork-based version of pgbench
MIME-Version: 1.0
Content-Type: multipart/mixed; boundary="----- =_aaaaaaaaaa0"
Content-ID: <17371(dot)1133472864(dot)0(at)sss(dot)pgh(dot)pa(dot)us>
Date: Thu, 01 Dec 2005 16:34:46 -0500
Message-ID: <17376(dot)1133472886(at)sss(dot)pgh(dot)pa(dot)us>
From: Tom Lane <tgl(at)sss(dot)pgh(dot)pa(dot)us>
X-Virus-Scanned: by amavisd-new at hub.org
X-Spam-Status: No, score=0 required=5 tests=[none]
X-Spam-Score: 0
X-Spam-Level:
X-Archive-Number: 200512/18
X-Sequence-Number: 17977

------- =_aaaaaaaaaa0
Content-Type: text/plain; charset="us-ascii"
Content-ID: <17371(dot)1133472864(dot)1(at)sss(dot)pgh(dot)pa(dot)us>

Argh, I'm an idiot ... a big part of the problem with the original
fork-based pgbench is that I'd rearranged the startup code without
noticing a data dependency. You can't initialize the default scripts
until you've gotten the correct value of "tps" by inspecting the
database. What was happening was that it was making tps = 1 always,
which meant that every transaction tried to update the bid = 1 row
of "branches", which resulted in strict serialization of transactions.
Performance of the attached version is markedly better ;-)

regards, tom lane

------- =_aaaaaaaaaa0
Content-Type: application/octet-stream
Content-ID: <17371(dot)1133472864(dot)2(at)sss(dot)pgh(dot)pa(dot)us>
Content-Description: pgbench.c
Content-Transfer-Encoding: base64
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------- =_aaaaaaaaaa0--

On 12/1/05, Bruce Momjian <pgman(at)candle(dot)pha(dot)pa(dot)us> wrote:
> Where are we on this patch? Is it to be applied?

After Tom's advice (he was doubtful about the patch), while I was
thinking about how to improve the spectrum of tests, decided to use
src/test/mb. In the tests, patch just succeded for unicode and failed
on big5, euc_cn, euc_jp, euc_kr, euc_tw, mule_internal, sjis
encodings. Fails' reason can be my wrong configuration too. (I've made
tests on a both unicode and latin-5 encoded databases.)

AFAIC, euc* encodings break latin-n and fixed latin-n encodings break
euc*. Seems like a deadlock. Furthermore, I'm not aware of the status
of ICU (will it be applied with 8.2?), thus we can go a way through
like distributing latin-n fixed PostgreSQL sources/binaries on
postgresql.org.tr.

Regards.

Volkan YAZICI wrote:
> On 12/1/05, Bruce Momjian <pgman(at)candle(dot)pha(dot)pa(dot)us> wrote:
> > Where are we on this patch? Is it to be applied?
>
> After Tom's advice (he was doubtful about the patch), while I was
> thinking about how to improve the spectrum of tests, decided to use
> src/test/mb. In the tests, patch just succeded for unicode and failed
> on big5, euc_cn, euc_jp, euc_kr, euc_tw, mule_internal, sjis
> encodings. Fails' reason can be my wrong configuration too. (I've made
> tests on a both unicode and latin-5 encoded databases.)

Do those encodings even have uppercase letters?

> AFAIC, euc* encodings break latin-n and fixed latin-n encodings break
> euc*. Seems like a deadlock. Furthermore, I'm not aware of the status
> of ICU (will it be applied with 8.2?), thus we can go a way through
> like distributing latin-n fixed PostgreSQL sources/binaries on
> postgresql.org.tr.

People have talked about ICU but I don't know if anyone is working on it
now.

I think the big problem is that while your patch works for some cases,
it fails for others, and there is no good way to know/test which will
work and which will not. Is that accurate?

--
Bruce Momjian | http://candle.pha.pa.us
pgman(at)candle(dot)pha(dot)pa(dot)us | (610) 359-1001
+ If your life is a hard drive, | 13 Roberts Road
+ Christ can be your backup. | Newtown Square, Pennsylvania 19073

Last minute edit:
src/test/mb seems a little bit old. I've tested SQL files in
src/test/mb/sql with the expected results in src/test/mb/expected
manually and it worked. (Output files need a little bit editing, like
removing lines similar to "CREATE TABLE".) But it'll be better if any
EUC users will try 'em manually too.

On 12/2/05, Bruce Momjian <pgman(at)candle(dot)pha(dot)pa(dot)us> wrote:
> Volkan YAZICI wrote:
> > After Tom's advice (he was doubtful about the patch), while I was
> > thinking about how to improve the spectrum of tests, decided to use
> > src/test/mb. In the tests, patch just succeded for unicode and failed
> > on big5, euc_cn, euc_jp, euc_kr, euc_tw, mule_internal, sjis
> > encodings. Fails' reason can be my wrong configuration too. (I've made
> > tests on a both unicode and latin-5 encoded databases.)
>
> Do those encodings even have uppercase letters?

According to what IRC folks, yes.

> People have talked about ICU but I don't know if anyone is working on it
> now.

Furthermore, there're some unofficial ICU patches for PostgreSQL
around. Like the one @
http://people.freebsd.org/~girgen/postgresql-icu/README.html

> I think the big problem is that while your patch works for some cases,
> it fails for others

As I mentioned in the above, it seems like it's working for other ones too.

> and there is no good way to know/test which will
> work and which will not. Is that accurate?

You don't want to commit this patch because it breaks[*] EUC like
encodings. But OTOH, it fixes LatinN and UNICODE encodings. I'm really
wondering, while we're trying to protect the EUC encodings still
working, why there's not any EUC users around to take care of EUC
tests? Doesn't EUC have any problems? Do ILIKE, upper/lower work for
them properly?

[*] If I didn't make a mistake, manual tests succeded for EUC like
encodings too.

You can think the reverse of the subject too. Think LatinN and UNICODE
as working and somebody submitted a patch which fixes EUC encodings by
breaking the previous ones. What will be the reaction of PostgreSQL
team in this situation?

Regards.