src/test/regress/expected/collate.icu.utf8.out

   1 /*
   2  * This test is for ICU collations.
   3  */
   4 /* skip test if not UTF8 server encoding or no ICU collations installed */
   5 SELECT getdatabaseencoding() <> 'UTF8' OR
   6        (SELECT count(*) FROM pg_collation WHERE collprovider = 'i') = 0
   7        AS skip_test \gset
   8 \if :skip_test
   9 \quit
  10 \endif
  11 SET client_encoding TO UTF8;
  12 CREATE SCHEMA collate_tests;
  13 SET search_path = collate_tests;
  14 CREATE TABLE collate_test1 (
  15     a int,
  16     b text COLLATE "en-x-icu" NOT NULL
  17 );
  18 \d collate_test1
  19         Table "collate_tests.collate_test1"
  20  Column |  Type   | Collation | Nullable | Default
  21 --------+---------+-----------+----------+---------
  22  a      | integer |           |          |
  23  b      | text    | en-x-icu  | not null |
  24
  25 CREATE TABLE collate_test_fail (
  26     a int,
  27     b text COLLATE "ja_JP.eucjp-x-icu"
  28 );
  29 ERROR:  collation "ja_JP.eucjp-x-icu" for encoding "UTF8" does not exist
  30 LINE 3:     b text COLLATE "ja_JP.eucjp-x-icu"
  31                    ^
  32 CREATE TABLE collate_test_fail (
  33     a int,
  34     b text COLLATE "foo-x-icu"
  35 );
  36 ERROR:  collation "foo-x-icu" for encoding "UTF8" does not exist
  37 LINE 3:     b text COLLATE "foo-x-icu"
  38                    ^
  39 CREATE TABLE collate_test_fail (
  40     a int COLLATE "en-x-icu",
  41     b text
  42 );
  43 ERROR:  collations are not supported by type integer
  44 LINE 2:     a int COLLATE "en-x-icu",
  45                   ^
  46 CREATE TABLE collate_test_like (
  47     LIKE collate_test1
  48 );
  49 \d collate_test_like
  50       Table "collate_tests.collate_test_like"
  51  Column |  Type   | Collation | Nullable | Default
  52 --------+---------+-----------+----------+---------
  53  a      | integer |           |          |
  54  b      | text    | en-x-icu  | not null |
  55
  56 CREATE TABLE collate_test2 (
  57     a int,
  58     b text COLLATE "sv-x-icu"
  59 );
  60 CREATE TABLE collate_test3 (
  61     a int,
  62     b text COLLATE "C"
  63 );
  64 INSERT INTO collate_test1 VALUES (1, 'abc'), (2, 'äbc'), (3, 'bbc'), (4, 'ABC');
  65 INSERT INTO collate_test2 SELECT * FROM collate_test1;
  66 INSERT INTO collate_test3 SELECT * FROM collate_test1;
  67 SELECT * FROM collate_test1 WHERE b >= 'bbc';
  68  a |  b
  69 ---+-----
  70  3 | bbc
  71 (1 row)
  72
  73 SELECT * FROM collate_test2 WHERE b >= 'bbc';
  74  a |  b
  75 ---+-----
  76  2 | äbc
  77  3 | bbc
  78 (2 rows)
  79
  80 SELECT * FROM collate_test3 WHERE b >= 'bbc';
  81  a |  b
  82 ---+-----
  83  2 | äbc
  84  3 | bbc
  85 (2 rows)
  86
  87 SELECT * FROM collate_test3 WHERE b >= 'BBC';
  88  a |  b
  89 ---+-----
  90  1 | abc
  91  2 | äbc
  92  3 | bbc
  93 (3 rows)
  94
  95 SELECT * FROM collate_test1 WHERE b COLLATE "C" >= 'bbc';
  96  a |  b
  97 ---+-----
  98  2 | äbc
  99  3 | bbc
 100 (2 rows)
 101
 102 SELECT * FROM collate_test1 WHERE b >= 'bbc' COLLATE "C";
 103  a |  b
 104 ---+-----
 105  2 | äbc
 106  3 | bbc
 107 (2 rows)
 108
 109 SELECT * FROM collate_test1 WHERE b COLLATE "C" >= 'bbc' COLLATE "C";
 110  a |  b
 111 ---+-----
 112  2 | äbc
 113  3 | bbc
 114 (2 rows)
 115
 116 SELECT * FROM collate_test1 WHERE b COLLATE "C" >= 'bbc' COLLATE "en-x-icu";
 117 ERROR:  collation mismatch between explicit collations "C" and "en-x-icu"
 118 LINE 1: ...* FROM collate_test1 WHERE b COLLATE "C" >= 'bbc' COLLATE "e...
 119                                                              ^
 120 CREATE DOMAIN testdomain_sv AS text COLLATE "sv-x-icu";
 121 CREATE DOMAIN testdomain_i AS int COLLATE "sv-x-icu"; -- fails
 122 ERROR:  collations are not supported by type integer
 123 CREATE TABLE collate_test4 (
 124     a int,
 125     b testdomain_sv
 126 );
 127 INSERT INTO collate_test4 SELECT * FROM collate_test1;
 128 SELECT a, b FROM collate_test4 ORDER BY b;
 129  a |  b
 130 ---+-----
 131  1 | abc
 132  4 | ABC
 133  3 | bbc
 134  2 | äbc
 135 (4 rows)
 136
 137 CREATE TABLE collate_test5 (
 138     a int,
 139     b testdomain_sv COLLATE "en-x-icu"
 140 );
 141 INSERT INTO collate_test5 SELECT * FROM collate_test1;
 142 SELECT a, b FROM collate_test5 ORDER BY b;
 143  a |  b
 144 ---+-----
 145  1 | abc
 146  4 | ABC
 147  2 | äbc
 148  3 | bbc
 149 (4 rows)
 150
 151 SELECT a, b FROM collate_test1 ORDER BY b;
 152  a |  b
 153 ---+-----
 154  1 | abc
 155  4 | ABC
 156  2 | äbc
 157  3 | bbc
 158 (4 rows)
 159
 160 SELECT a, b FROM collate_test2 ORDER BY b;
 161  a |  b
 162 ---+-----
 163  1 | abc
 164  4 | ABC
 165  3 | bbc
 166  2 | äbc
 167 (4 rows)
 168
 169 SELECT a, b FROM collate_test3 ORDER BY b;
 170  a |  b
 171 ---+-----
 172  4 | ABC
 173  1 | abc
 174  3 | bbc
 175  2 | äbc
 176 (4 rows)
 177
 178 SELECT a, b FROM collate_test1 ORDER BY b COLLATE "C";
 179  a |  b
 180 ---+-----
 181  4 | ABC
 182  1 | abc
 183  3 | bbc
 184  2 | äbc
 185 (4 rows)
 186
 187 -- star expansion
 188 SELECT * FROM collate_test1 ORDER BY b;
 189  a |  b
 190 ---+-----
 191  1 | abc
 192  4 | ABC
 193  2 | äbc
 194  3 | bbc
 195 (4 rows)
 196
 197 SELECT * FROM collate_test2 ORDER BY b;
 198  a |  b
 199 ---+-----
 200  1 | abc
 201  4 | ABC
 202  3 | bbc
 203  2 | äbc
 204 (4 rows)
 205
 206 SELECT * FROM collate_test3 ORDER BY b;
 207  a |  b
 208 ---+-----
 209  4 | ABC
 210  1 | abc
 211  3 | bbc
 212  2 | äbc
 213 (4 rows)
 214
 215 -- constant expression folding
 216 SELECT 'bbc' COLLATE "en-x-icu" > 'äbc' COLLATE "en-x-icu" AS "true";
 217  true
 218 ------
 219  t
 220 (1 row)
 221
 222 SELECT 'bbc' COLLATE "sv-x-icu" > 'äbc' COLLATE "sv-x-icu" AS "false";
 223  false
 224 -------
 225  f
 226 (1 row)
 227
 228 -- upper/lower
 229 CREATE TABLE collate_test10 (
 230     a int,
 231     x text COLLATE "en-x-icu",
 232     y text COLLATE "tr-x-icu"
 233 );
 234 INSERT INTO collate_test10 VALUES (1, 'hij', 'hij'), (2, 'HIJ', 'HIJ');
 235 SELECT a, lower(x), lower(y), upper(x), upper(y), initcap(x), initcap(y) FROM collate_test10;
 236  a | lower | lower | upper | upper | initcap | initcap
 237 ---+-------+-------+-------+-------+---------+---------
 238  1 | hij   | hij   | HIJ   | HİJ   | Hij     | Hij
 239  2 | hij   | hıj   | HIJ   | HIJ   | Hij     | Hıj
 240 (2 rows)
 241
 242 SELECT a, lower(x COLLATE "C"), lower(y COLLATE "C") FROM collate_test10;
 243  a | lower | lower
 244 ---+-------+-------
 245  1 | hij   | hij
 246  2 | hij   | hij
 247 (2 rows)
 248
 249 SELECT a, x, y FROM collate_test10 ORDER BY lower(y), a;
 250  a |  x  |  y
 251 ---+-----+-----
 252  2 | HIJ | HIJ
 253  1 | hij | hij
 254 (2 rows)
 255
 256 -- LIKE/ILIKE
 257 SELECT * FROM collate_test1 WHERE b LIKE 'abc';
 258  a |  b
 259 ---+-----
 260  1 | abc
 261 (1 row)
 262
 263 SELECT * FROM collate_test1 WHERE b LIKE 'abc%';
 264  a |  b
 265 ---+-----
 266  1 | abc
 267 (1 row)
 268
 269 SELECT * FROM collate_test1 WHERE b LIKE '%bc%';
 270  a |  b
 271 ---+-----
 272  1 | abc
 273  2 | äbc
 274  3 | bbc
 275 (3 rows)
 276
 277 SELECT * FROM collate_test1 WHERE b ILIKE 'abc';
 278  a |  b
 279 ---+-----
 280  1 | abc
 281  4 | ABC
 282 (2 rows)
 283
 284 SELECT * FROM collate_test1 WHERE b ILIKE 'abc%';
 285  a |  b
 286 ---+-----
 287  1 | abc
 288  4 | ABC
 289 (2 rows)
 290
 291 SELECT * FROM collate_test1 WHERE b ILIKE '%bc%';
 292  a |  b
 293 ---+-----
 294  1 | abc
 295  2 | äbc
 296  3 | bbc
 297  4 | ABC
 298 (4 rows)
 299
 300 SELECT 'Türkiye' COLLATE "en-x-icu" ILIKE '%KI%' AS "true";
 301  true
 302 ------
 303  t
 304 (1 row)
 305
 306 SELECT 'Türkiye' COLLATE "tr-x-icu" ILIKE '%KI%' AS "false";
 307  false
 308 -------
 309  f
 310 (1 row)
 311
 312 SELECT 'bıt' ILIKE 'BIT' COLLATE "en-x-icu" AS "false";
 313  false
 314 -------
 315  f
 316 (1 row)
 317
 318 SELECT 'bıt' ILIKE 'BIT' COLLATE "tr-x-icu" AS "true";
 319  true
 320 ------
 321  t
 322 (1 row)
 323
 324 -- The following actually exercises the selectivity estimation for ILIKE.
 325 SELECT relname FROM pg_class WHERE relname ILIKE 'abc%';
 326  relname
 327 ---------
 328 (0 rows)
 329
 330 -- regular expressions
 331 SELECT * FROM collate_test1 WHERE b ~ '^abc$';
 332  a |  b
 333 ---+-----
 334  1 | abc
 335 (1 row)
 336
 337 SELECT * FROM collate_test1 WHERE b ~ '^abc';
 338  a |  b
 339 ---+-----
 340  1 | abc
 341 (1 row)
 342
 343 SELECT * FROM collate_test1 WHERE b ~ 'bc';
 344  a |  b
 345 ---+-----
 346  1 | abc
 347  2 | äbc
 348  3 | bbc
 349 (3 rows)
 350
 351 SELECT * FROM collate_test1 WHERE b ~* '^abc$';
 352  a |  b
 353 ---+-----
 354  1 | abc
 355  4 | ABC
 356 (2 rows)
 357
 358 SELECT * FROM collate_test1 WHERE b ~* '^abc';
 359  a |  b
 360 ---+-----
 361  1 | abc
 362  4 | ABC
 363 (2 rows)
 364
 365 SELECT * FROM collate_test1 WHERE b ~* 'bc';
 366  a |  b
 367 ---+-----
 368  1 | abc
 369  2 | äbc
 370  3 | bbc
 371  4 | ABC
 372 (4 rows)
 373
 374 CREATE TABLE collate_test6 (
 375     a int,
 376     b text COLLATE "en-x-icu"
 377 );
 378 INSERT INTO collate_test6 VALUES (1, 'abc'), (2, 'ABC'), (3, '123'), (4, 'ab1'),
 379                                  (5, 'a1!'), (6, 'a c'), (7, '!.;'), (8, '   '),
 380                                  (9, 'äbç'), (10, 'ÄBÇ');
 381 SELECT b,
 382        b ~ '^[[:alpha:]]+$' AS is_alpha,
 383        b ~ '^[[:upper:]]+$' AS is_upper,
 384        b ~ '^[[:lower:]]+$' AS is_lower,
 385        b ~ '^[[:digit:]]+$' AS is_digit,
 386        b ~ '^[[:alnum:]]+$' AS is_alnum,
 387        b ~ '^[[:graph:]]+$' AS is_graph,
 388        b ~ '^[[:print:]]+$' AS is_print,
 389        b ~ '^[[:punct:]]+$' AS is_punct,
 390        b ~ '^[[:space:]]+$' AS is_space
 391 FROM collate_test6;
 392   b  | is_alpha | is_upper | is_lower | is_digit | is_alnum | is_graph | is_print | is_punct | is_space
 393 -----+----------+----------+----------+----------+----------+----------+----------+----------+----------
 394  abc | t        | f        | t        | f        | t        | t        | t        | f        | f
 395  ABC | t        | t        | f        | f        | t        | t        | t        | f        | f
 396  123 | f        | f        | f        | t        | t        | t        | t        | f        | f
 397  ab1 | f        | f        | f        | f        | t        | t        | t        | f        | f
 398  a1! | f        | f        | f        | f        | f        | t        | t        | f        | f
 399  a c | f        | f        | f        | f        | f        | f        | t        | f        | f
 400  !.; | f        | f        | f        | f        | f        | t        | t        | t        | f
 401      | f        | f        | f        | f        | f        | f        | t        | f        | t
 402  äbç | t        | f        | t        | f        | t        | t        | t        | f        | f
 403  ÄBÇ | t        | t        | f        | f        | t        | t        | t        | f        | f
 404 (10 rows)
 405
 406 SELECT 'Türkiye' COLLATE "en-x-icu" ~* 'KI' AS "true";
 407  true
 408 ------
 409  t
 410 (1 row)
 411
 412 SELECT 'Türkiye' COLLATE "tr-x-icu" ~* 'KI' AS "true";  -- true with ICU
 413  true
 414 ------
 415  t
 416 (1 row)
 417
 418 SELECT 'bıt' ~* 'BIT' COLLATE "en-x-icu" AS "false";
 419  false
 420 -------
 421  f
 422 (1 row)
 423
 424 SELECT 'bıt' ~* 'BIT' COLLATE "tr-x-icu" AS "false";  -- false with ICU
 425  false
 426 -------
 427  f
 428 (1 row)
 429
 430 -- The following actually exercises the selectivity estimation for ~*.
 431 SELECT relname FROM pg_class WHERE relname ~* '^abc';
 432  relname
 433 ---------
 434 (0 rows)
 435
 436 /* not run by default because it requires tr_TR system locale
 437 -- to_char
 438
 439 SET lc_time TO 'tr_TR';
 440 SELECT to_char(date '2010-04-01', 'DD TMMON YYYY');
 441 SELECT to_char(date '2010-04-01', 'DD TMMON YYYY' COLLATE "tr-x-icu");
 442 */
 443 -- backwards parsing
 444 CREATE VIEW collview1 AS SELECT * FROM collate_test1 WHERE b COLLATE "C" >= 'bbc';
 445 CREATE VIEW collview2 AS SELECT a, b FROM collate_test1 ORDER BY b COLLATE "C";
 446 CREATE VIEW collview3 AS SELECT a, lower((x || x) COLLATE "C") FROM collate_test10;
 447 SELECT table_name, view_definition FROM information_schema.views
 448   WHERE table_name LIKE 'collview%' ORDER BY 1;
 449  table_name |                             view_definition
 450 ------------+--------------------------------------------------------------------------
 451  collview1  |  SELECT collate_test1.a,                                                +
 452             |     collate_test1.b                                                     +
 453             |    FROM collate_test1                                                   +
 454             |   WHERE ((collate_test1.b COLLATE "C") >= 'bbc'::text);
 455  collview2  |  SELECT collate_test1.a,                                                +
 456             |     collate_test1.b                                                     +
 457             |    FROM collate_test1                                                   +
 458             |   ORDER BY (collate_test1.b COLLATE "C");
 459  collview3  |  SELECT collate_test10.a,                                               +
 460             |     lower(((collate_test10.x || collate_test10.x) COLLATE "C")) AS lower+
 461             |    FROM collate_test10;
 462 (3 rows)
 463
 464 -- collation propagation in various expression types
 465 SELECT a, coalesce(b, 'foo') FROM collate_test1 ORDER BY 2;
 466  a | coalesce
 467 ---+----------
 468  1 | abc
 469  4 | ABC
 470  2 | äbc
 471  3 | bbc
 472 (4 rows)
 473
 474 SELECT a, coalesce(b, 'foo') FROM collate_test2 ORDER BY 2;
 475  a | coalesce
 476 ---+----------
 477  1 | abc
 478  4 | ABC
 479  3 | bbc
 480  2 | äbc
 481 (4 rows)
 482
 483 SELECT a, coalesce(b, 'foo') FROM collate_test3 ORDER BY 2;
 484  a | coalesce
 485 ---+----------
 486  4 | ABC
 487  1 | abc
 488  3 | bbc
 489  2 | äbc
 490 (4 rows)
 491
 492 SELECT a, lower(coalesce(x, 'foo')), lower(coalesce(y, 'foo')) FROM collate_test10;
 493  a | lower | lower
 494 ---+-------+-------
 495  1 | hij   | hij
 496  2 | hij   | hıj
 497 (2 rows)
 498
 499 SELECT a, b, greatest(b, 'CCC') FROM collate_test1 ORDER BY 3;
 500  a |  b  | greatest
 501 ---+-----+----------
 502  1 | abc | CCC
 503  2 | äbc | CCC
 504  3 | bbc | CCC
 505  4 | ABC | CCC
 506 (4 rows)
 507
 508 SELECT a, b, greatest(b, 'CCC') FROM collate_test2 ORDER BY 3;
 509  a |  b  | greatest
 510 ---+-----+----------
 511  1 | abc | CCC
 512  3 | bbc | CCC
 513  4 | ABC | CCC
 514  2 | äbc | äbc
 515 (4 rows)
 516
 517 SELECT a, b, greatest(b, 'CCC') FROM collate_test3 ORDER BY 3;
 518  a |  b  | greatest
 519 ---+-----+----------
 520  4 | ABC | CCC
 521  1 | abc | abc
 522  3 | bbc | bbc
 523  2 | äbc | äbc
 524 (4 rows)
 525
 526 SELECT a, x, y, lower(greatest(x, 'foo')), lower(greatest(y, 'foo')) FROM collate_test10;
 527  a |  x  |  y  | lower | lower
 528 ---+-----+-----+-------+-------
 529  1 | hij | hij | hij   | hij
 530  2 | HIJ | HIJ | hij   | hıj
 531 (2 rows)
 532
 533 SELECT a, nullif(b, 'abc') FROM collate_test1 ORDER BY 2;
 534  a | nullif
 535 ---+--------
 536  4 | ABC
 537  2 | äbc
 538  3 | bbc
 539  1 |
 540 (4 rows)
 541
 542 SELECT a, nullif(b, 'abc') FROM collate_test2 ORDER BY 2;
 543  a | nullif
 544 ---+--------
 545  4 | ABC
 546  3 | bbc
 547  2 | äbc
 548  1 |
 549 (4 rows)
 550
 551 SELECT a, nullif(b, 'abc') FROM collate_test3 ORDER BY 2;
 552  a | nullif
 553 ---+--------
 554  4 | ABC
 555  3 | bbc
 556  2 | äbc
 557  1 |
 558 (4 rows)
 559
 560 SELECT a, lower(nullif(x, 'foo')), lower(nullif(y, 'foo')) FROM collate_test10;
 561  a | lower | lower
 562 ---+-------+-------
 563  1 | hij   | hij
 564  2 | hij   | hıj
 565 (2 rows)
 566
 567 SELECT a, CASE b WHEN 'abc' THEN 'abcd' ELSE b END FROM collate_test1 ORDER BY 2;
 568  a |  b
 569 ---+------
 570  4 | ABC
 571  2 | äbc
 572  1 | abcd
 573  3 | bbc
 574 (4 rows)
 575
 576 SELECT a, CASE b WHEN 'abc' THEN 'abcd' ELSE b END FROM collate_test2 ORDER BY 2;
 577  a |  b
 578 ---+------
 579  4 | ABC
 580  1 | abcd
 581  3 | bbc
 582  2 | äbc
 583 (4 rows)
 584
 585 SELECT a, CASE b WHEN 'abc' THEN 'abcd' ELSE b END FROM collate_test3 ORDER BY 2;
 586  a |  b
 587 ---+------
 588  4 | ABC
 589  1 | abcd
 590  3 | bbc
 591  2 | äbc
 592 (4 rows)
 593
 594 CREATE DOMAIN testdomain AS text;
 595 SELECT a, b::testdomain FROM collate_test1 ORDER BY 2;
 596  a |  b
 597 ---+-----
 598  1 | abc
 599  4 | ABC
 600  2 | äbc
 601  3 | bbc
 602 (4 rows)
 603
 604 SELECT a, b::testdomain FROM collate_test2 ORDER BY 2;
 605  a |  b
 606 ---+-----
 607  1 | abc
 608  4 | ABC
 609  3 | bbc
 610  2 | äbc
 611 (4 rows)
 612
 613 SELECT a, b::testdomain FROM collate_test3 ORDER BY 2;
 614  a |  b
 615 ---+-----
 616  4 | ABC
 617  1 | abc
 618  3 | bbc
 619  2 | äbc
 620 (4 rows)
 621
 622 SELECT a, b::testdomain_sv FROM collate_test3 ORDER BY 2;
 623  a |  b
 624 ---+-----
 625  1 | abc
 626  4 | ABC
 627  3 | bbc
 628  2 | äbc
 629 (4 rows)
 630
 631 SELECT a, lower(x::testdomain), lower(y::testdomain) FROM collate_test10;
 632  a | lower | lower
 633 ---+-------+-------
 634  1 | hij   | hij
 635  2 | hij   | hıj
 636 (2 rows)
 637
 638 SELECT min(b), max(b) FROM collate_test1;
 639  min | max
 640 -----+-----
 641  abc | bbc
 642 (1 row)
 643
 644 SELECT min(b), max(b) FROM collate_test2;
 645  min | max
 646 -----+-----
 647  abc | äbc
 648 (1 row)
 649
 650 SELECT min(b), max(b) FROM collate_test3;
 651  min | max
 652 -----+-----
 653  ABC | äbc
 654 (1 row)
 655
 656 SELECT array_agg(b ORDER BY b) FROM collate_test1;
 657      array_agg
 658 -------------------
 659  {abc,ABC,äbc,bbc}
 660 (1 row)
 661
 662 SELECT array_agg(b ORDER BY b) FROM collate_test2;
 663      array_agg
 664 -------------------
 665  {abc,ABC,bbc,äbc}
 666 (1 row)
 667
 668 SELECT array_agg(b ORDER BY b) FROM collate_test3;
 669      array_agg
 670 -------------------
 671  {ABC,abc,bbc,äbc}
 672 (1 row)
 673
 674 SELECT a, b FROM collate_test1 UNION ALL SELECT a, b FROM collate_test1 ORDER BY 2;
 675  a |  b
 676 ---+-----
 677  1 | abc
 678  1 | abc
 679  4 | ABC
 680  4 | ABC
 681  2 | äbc
 682  2 | äbc
 683  3 | bbc
 684  3 | bbc
 685 (8 rows)
 686
 687 SELECT a, b FROM collate_test2 UNION SELECT a, b FROM collate_test2 ORDER BY 2;
 688  a |  b
 689 ---+-----
 690  1 | abc
 691  4 | ABC
 692  3 | bbc
 693  2 | äbc
 694 (4 rows)
 695
 696 SELECT a, b FROM collate_test3 WHERE a < 4 INTERSECT SELECT a, b FROM collate_test3 WHERE a > 1 ORDER BY 2;
 697  a |  b
 698 ---+-----
 699  3 | bbc
 700  2 | äbc
 701 (2 rows)
 702
 703 SELECT a, b FROM collate_test3 EXCEPT SELECT a, b FROM collate_test3 WHERE a < 2 ORDER BY 2;
 704  a |  b
 705 ---+-----
 706  4 | ABC
 707  3 | bbc
 708  2 | äbc
 709 (3 rows)
 710
 711 SELECT a, b FROM collate_test1 UNION ALL SELECT a, b FROM collate_test3 ORDER BY 2; -- fail
 712 ERROR:  could not determine which collation to use for string comparison
 713 HINT:  Use the COLLATE clause to set the collation explicitly.
 714 SELECT a, b FROM collate_test1 UNION ALL SELECT a, b FROM collate_test3; -- ok
 715  a |  b
 716 ---+-----
 717  1 | abc
 718  2 | äbc
 719  3 | bbc
 720  4 | ABC
 721  1 | abc
 722  2 | äbc
 723  3 | bbc
 724  4 | ABC
 725 (8 rows)
 726
 727 SELECT a, b FROM collate_test1 UNION SELECT a, b FROM collate_test3 ORDER BY 2; -- fail
 728 ERROR:  collation mismatch between implicit collations "en-x-icu" and "C"
 729 LINE 1: SELECT a, b FROM collate_test1 UNION SELECT a, b FROM collat...
 730                                                        ^
 731 HINT:  You can choose the collation by applying the COLLATE clause to one or both expressions.
 732 SELECT a, b COLLATE "C" FROM collate_test1 UNION SELECT a, b FROM collate_test3 ORDER BY 2; -- ok
 733  a |  b
 734 ---+-----
 735  4 | ABC
 736  1 | abc
 737  3 | bbc
 738  2 | äbc
 739 (4 rows)
 740
 741 SELECT a, b FROM collate_test1 INTERSECT SELECT a, b FROM collate_test3 ORDER BY 2; -- fail
 742 ERROR:  collation mismatch between implicit collations "en-x-icu" and "C"
 743 LINE 1: ...ELECT a, b FROM collate_test1 INTERSECT SELECT a, b FROM col...
 744                                                              ^
 745 HINT:  You can choose the collation by applying the COLLATE clause to one or both expressions.
 746 SELECT a, b FROM collate_test1 EXCEPT SELECT a, b FROM collate_test3 ORDER BY 2; -- fail
 747 ERROR:  collation mismatch between implicit collations "en-x-icu" and "C"
 748 LINE 1: SELECT a, b FROM collate_test1 EXCEPT SELECT a, b FROM colla...
 749                                                         ^
 750 HINT:  You can choose the collation by applying the COLLATE clause to one or both expressions.
 751 CREATE TABLE test_u AS SELECT a, b FROM collate_test1 UNION ALL SELECT a, b FROM collate_test3; -- fail
 752 ERROR:  no collation was derived for column "b" with collatable type text
 753 HINT:  Use the COLLATE clause to set the collation explicitly.
 754 -- ideally this would be a parse-time error, but for now it must be run-time:
 755 select x < y from collate_test10; -- fail
 756 ERROR:  could not determine which collation to use for string comparison
 757 HINT:  Use the COLLATE clause to set the collation explicitly.
 758 select x || y from collate_test10; -- ok, because || is not collation aware
 759  ?column?
 760 ----------
 761  hijhij
 762  HIJHIJ
 763 (2 rows)
 764
 765 select x, y from collate_test10 order by x || y; -- not so ok
 766 ERROR:  collation mismatch between implicit collations "en-x-icu" and "tr-x-icu"
 767 LINE 1: select x, y from collate_test10 order by x || y;
 768                                                       ^
 769 HINT:  You can choose the collation by applying the COLLATE clause to one or both expressions.
 770 -- collation mismatch between recursive and non-recursive term
 771 WITH RECURSIVE foo(x) AS
 772    (SELECT x FROM (VALUES('a' COLLATE "en-x-icu"),('b')) t(x)
 773    UNION ALL
 774    SELECT (x || 'c') COLLATE "de-x-icu" FROM foo WHERE length(x) < 10)
 775 SELECT * FROM foo;
 776 ERROR:  recursive query "foo" column 1 has collation "en-x-icu" in non-recursive term but collation "de-x-icu" overall
 777 LINE 2:    (SELECT x FROM (VALUES('a' COLLATE "en-x-icu"),('b')) t(x...
 778                    ^
 779 HINT:  Use the COLLATE clause to set the collation of the non-recursive term.
 780 -- casting
 781 SELECT CAST('42' AS text COLLATE "C");
 782 ERROR:  syntax error at or near "COLLATE"
 783 LINE 1: SELECT CAST('42' AS text COLLATE "C");
 784                                  ^
 785 SELECT a, CAST(b AS varchar) FROM collate_test1 ORDER BY 2;
 786  a |  b
 787 ---+-----
 788  1 | abc
 789  4 | ABC
 790  2 | äbc
 791  3 | bbc
 792 (4 rows)
 793
 794 SELECT a, CAST(b AS varchar) FROM collate_test2 ORDER BY 2;
 795  a |  b
 796 ---+-----
 797  1 | abc
 798  4 | ABC
 799  3 | bbc
 800  2 | äbc
 801 (4 rows)
 802
 803 SELECT a, CAST(b AS varchar) FROM collate_test3 ORDER BY 2;
 804  a |  b
 805 ---+-----
 806  4 | ABC
 807  1 | abc
 808  3 | bbc
 809  2 | äbc
 810 (4 rows)
 811
 812 -- propagation of collation in SQL functions (inlined and non-inlined cases)
 813 -- and plpgsql functions too
 814 CREATE FUNCTION mylt (text, text) RETURNS boolean LANGUAGE sql
 815     AS $$ select $1 < $2 $$;
 816 CREATE FUNCTION mylt_noninline (text, text) RETURNS boolean LANGUAGE sql
 817     AS $$ select $1 < $2 limit 1 $$;
 818 CREATE FUNCTION mylt_plpgsql (text, text) RETURNS boolean LANGUAGE plpgsql
 819     AS $$ begin return $1 < $2; end $$;
 820 SELECT a.b AS a, b.b AS b, a.b < b.b AS lt,
 821        mylt(a.b, b.b), mylt_noninline(a.b, b.b), mylt_plpgsql(a.b, b.b)
 822 FROM collate_test1 a, collate_test1 b
 823 ORDER BY a.b, b.b;
 824   a  |  b  | lt | mylt | mylt_noninline | mylt_plpgsql
 825 -----+-----+----+------+----------------+--------------
 826  abc | abc | f  | f    | f              | f
 827  abc | ABC | t  | t    | t              | t
 828  abc | äbc | t  | t    | t              | t
 829  abc | bbc | t  | t    | t              | t
 830  ABC | abc | f  | f    | f              | f
 831  ABC | ABC | f  | f    | f              | f
 832  ABC | äbc | t  | t    | t              | t
 833  ABC | bbc | t  | t    | t              | t
 834  äbc | abc | f  | f    | f              | f
 835  äbc | ABC | f  | f    | f              | f
 836  äbc | äbc | f  | f    | f              | f
 837  äbc | bbc | t  | t    | t              | t
 838  bbc | abc | f  | f    | f              | f
 839  bbc | ABC | f  | f    | f              | f
 840  bbc | äbc | f  | f    | f              | f
 841  bbc | bbc | f  | f    | f              | f
 842 (16 rows)
 843
 844 SELECT a.b AS a, b.b AS b, a.b < b.b COLLATE "C" AS lt,
 845        mylt(a.b, b.b COLLATE "C"), mylt_noninline(a.b, b.b COLLATE "C"),
 846        mylt_plpgsql(a.b, b.b COLLATE "C")
 847 FROM collate_test1 a, collate_test1 b
 848 ORDER BY a.b, b.b;
 849   a  |  b  | lt | mylt | mylt_noninline | mylt_plpgsql
 850 -----+-----+----+------+----------------+--------------
 851  abc | abc | f  | f    | f              | f
 852  abc | ABC | f  | f    | f              | f
 853  abc | äbc | t  | t    | t              | t
 854  abc | bbc | t  | t    | t              | t
 855  ABC | abc | t  | t    | t              | t
 856  ABC | ABC | f  | f    | f              | f
 857  ABC | äbc | t  | t    | t              | t
 858  ABC | bbc | t  | t    | t              | t
 859  äbc | abc | f  | f    | f              | f
 860  äbc | ABC | f  | f    | f              | f
 861  äbc | äbc | f  | f    | f              | f
 862  äbc | bbc | f  | f    | f              | f
 863  bbc | abc | f  | f    | f              | f
 864  bbc | ABC | f  | f    | f              | f
 865  bbc | äbc | t  | t    | t              | t
 866  bbc | bbc | f  | f    | f              | f
 867 (16 rows)
 868
 869 -- collation override in plpgsql
 870 CREATE FUNCTION mylt2 (x text, y text) RETURNS boolean LANGUAGE plpgsql AS $$
 871 declare
 872   xx text := x;
 873   yy text := y;
 874 begin
 875   return xx < yy;
 876 end
 877 $$;
 878 SELECT mylt2('a', 'B' collate "en-x-icu") as t, mylt2('a', 'B' collate "C") as f;
 879  t | f
 880 ---+---
 881  t | f
 882 (1 row)
 883
 884 CREATE OR REPLACE FUNCTION
 885   mylt2 (x text, y text) RETURNS boolean LANGUAGE plpgsql AS $$
 886 declare
 887   xx text COLLATE "POSIX" := x;
 888   yy text := y;
 889 begin
 890   return xx < yy;
 891 end
 892 $$;
 893 SELECT mylt2('a', 'B') as f;
 894  f
 895 ---
 896  f
 897 (1 row)
 898
 899 SELECT mylt2('a', 'B' collate "C") as fail; -- conflicting collations
 900 ERROR:  could not determine which collation to use for string comparison
 901 HINT:  Use the COLLATE clause to set the collation explicitly.
 902 CONTEXT:  PL/pgSQL function mylt2(text,text) line 6 at RETURN
 903 SELECT mylt2('a', 'B' collate "POSIX") as f;
 904  f
 905 ---
 906  f
 907 (1 row)
 908
 909 -- polymorphism
 910 SELECT * FROM unnest((SELECT array_agg(b ORDER BY b) FROM collate_test1)) ORDER BY 1;
 911  unnest
 912 --------
 913  abc
 914  ABC
 915  äbc
 916  bbc
 917 (4 rows)
 918
 919 SELECT * FROM unnest((SELECT array_agg(b ORDER BY b) FROM collate_test2)) ORDER BY 1;
 920  unnest
 921 --------
 922  abc
 923  ABC
 924  bbc
 925  äbc
 926 (4 rows)
 927
 928 SELECT * FROM unnest((SELECT array_agg(b ORDER BY b) FROM collate_test3)) ORDER BY 1;
 929  unnest
 930 --------
 931  ABC
 932  abc
 933  bbc
 934  äbc
 935 (4 rows)
 936
 937 CREATE FUNCTION dup (anyelement) RETURNS anyelement
 938     AS 'select $1' LANGUAGE sql;
 939 SELECT a, dup(b) FROM collate_test1 ORDER BY 2;
 940  a | dup
 941 ---+-----
 942  1 | abc
 943  4 | ABC
 944  2 | äbc
 945  3 | bbc
 946 (4 rows)
 947
 948 SELECT a, dup(b) FROM collate_test2 ORDER BY 2;
 949  a | dup
 950 ---+-----
 951  1 | abc
 952  4 | ABC
 953  3 | bbc
 954  2 | äbc
 955 (4 rows)
 956
 957 SELECT a, dup(b) FROM collate_test3 ORDER BY 2;
 958  a | dup
 959 ---+-----
 960  4 | ABC
 961  1 | abc
 962  3 | bbc
 963  2 | äbc
 964 (4 rows)
 965
 966 -- indexes
 967 CREATE INDEX collate_test1_idx1 ON collate_test1 (b);
 968 CREATE INDEX collate_test1_idx2 ON collate_test1 (b COLLATE "C");
 969 CREATE INDEX collate_test1_idx3 ON collate_test1 ((b COLLATE "C")); -- this is different grammatically
 970 CREATE INDEX collate_test1_idx4 ON collate_test1 (((b||'foo') COLLATE "POSIX"));
 971 CREATE INDEX collate_test1_idx5 ON collate_test1 (a COLLATE "C"); -- fail
 972 ERROR:  collations are not supported by type integer
 973 CREATE INDEX collate_test1_idx6 ON collate_test1 ((a COLLATE "C")); -- fail
 974 ERROR:  collations are not supported by type integer
 975 LINE 1: ...ATE INDEX collate_test1_idx6 ON collate_test1 ((a COLLATE "C...
 976                                                              ^
 977 SELECT relname, pg_get_indexdef(oid) FROM pg_class WHERE relname LIKE 'collate_test%_idx%' ORDER BY 1;
 978       relname       |                                                  pg_get_indexdef
 979 --------------------+-------------------------------------------------------------------------------------------------------------------
 980  collate_test1_idx1 | CREATE INDEX collate_test1_idx1 ON collate_tests.collate_test1 USING btree (b)
 981  collate_test1_idx2 | CREATE INDEX collate_test1_idx2 ON collate_tests.collate_test1 USING btree (b COLLATE "C")
 982  collate_test1_idx3 | CREATE INDEX collate_test1_idx3 ON collate_tests.collate_test1 USING btree (b COLLATE "C")
 983  collate_test1_idx4 | CREATE INDEX collate_test1_idx4 ON collate_tests.collate_test1 USING btree (((b || 'foo'::text)) COLLATE "POSIX")
 984 (4 rows)
 985
 986 set enable_seqscan = off;
 987 explain (costs off)
 988 select * from collate_test1 where b ilike 'abc';
 989           QUERY PLAN
 990 -------------------------------
 991  Seq Scan on collate_test1
 992    Filter: (b ~~* 'abc'::text)
 993 (2 rows)
 994
 995 select * from collate_test1 where b ilike 'abc';
 996  a |  b
 997 ---+-----
 998  1 | abc
 999  4 | ABC
1000 (2 rows)
1001
1002 explain (costs off)
1003 select * from collate_test1 where b ilike 'ABC';
1004           QUERY PLAN
1005 -------------------------------
1006  Seq Scan on collate_test1
1007    Filter: (b ~~* 'ABC'::text)
1008 (2 rows)
1009
1010 select * from collate_test1 where b ilike 'ABC';
1011  a |  b
1012 ---+-----
1013  1 | abc
1014  4 | ABC
1015 (2 rows)
1016
1017 reset enable_seqscan;
1018 -- schema manipulation commands
1019 CREATE ROLE regress_test_role;
1020 CREATE SCHEMA test_schema;
1021 -- We need to do this this way to cope with varying names for encodings:
1022 do $$
1023 BEGIN
1024   EXECUTE 'CREATE COLLATION test0 (provider = icu, locale = ' ||
1025           quote_literal(current_setting('lc_collate')) || ');';
1026 END
1027 $$;
1028 CREATE COLLATION test0 FROM "C"; -- fail, duplicate name
1029 ERROR:  collation "test0" already exists
1030 do $$
1031 BEGIN
1032   EXECUTE 'CREATE COLLATION test1 (provider = icu, lc_collate = ' ||
1033           quote_literal(current_setting('lc_collate')) ||
1034           ', lc_ctype = ' ||
1035           quote_literal(current_setting('lc_ctype')) || ');';
1036 END
1037 $$;
1038 CREATE COLLATION test3 (provider = icu, lc_collate = 'en_US.utf8'); -- fail, need lc_ctype
1039 ERROR:  parameter "lc_ctype" must be specified
1040 CREATE COLLATION testx (provider = icu, locale = 'nonsense'); /* never fails with ICU */  DROP COLLATION testx;
1041 CREATE COLLATION test4 FROM nonsense;
1042 ERROR:  collation "nonsense" for encoding "UTF8" does not exist
1043 CREATE COLLATION test5 FROM test0;
1044 SELECT collname FROM pg_collation WHERE collname LIKE 'test%' ORDER BY 1;
1045  collname
1046 ----------
1047  test0
1048  test1
1049  test5
1050 (3 rows)
1051
1052 ALTER COLLATION test1 RENAME TO test11;
1053 ALTER COLLATION test0 RENAME TO test11; -- fail
1054 ERROR:  collation "test11" already exists in schema "collate_tests"
1055 ALTER COLLATION test1 RENAME TO test22; -- fail
1056 ERROR:  collation "test1" for encoding "UTF8" does not exist
1057 ALTER COLLATION test11 OWNER TO regress_test_role;
1058 ALTER COLLATION test11 OWNER TO nonsense;
1059 ERROR:  role "nonsense" does not exist
1060 ALTER COLLATION test11 SET SCHEMA test_schema;
1061 COMMENT ON COLLATION test0 IS 'US English';
1062 SELECT collname, nspname, obj_description(pg_collation.oid, 'pg_collation')
1063     FROM pg_collation JOIN pg_namespace ON (collnamespace = pg_namespace.oid)
1064     WHERE collname LIKE 'test%'
1065     ORDER BY 1;
1066  collname |    nspname    | obj_description
1067 ----------+---------------+-----------------
1068  test0    | collate_tests | US English
1069  test11   | test_schema   |
1070  test5    | collate_tests |
1071 (3 rows)
1072
1073 DROP COLLATION test0, test_schema.test11, test5;
1074 DROP COLLATION test0; -- fail
1075 ERROR:  collation "test0" for encoding "UTF8" does not exist
1076 DROP COLLATION IF EXISTS test0;
1077 NOTICE:  collation "test0" does not exist, skipping
1078 SELECT collname FROM pg_collation WHERE collname LIKE 'test%';
1079  collname
1080 ----------
1081 (0 rows)
1082
1083 DROP SCHEMA test_schema;
1084 DROP ROLE regress_test_role;
1085 -- ALTER
1086 ALTER COLLATION "en-x-icu" REFRESH VERSION;
1087 NOTICE:  version has not changed
1088 -- dependencies
1089 CREATE COLLATION test0 FROM "C";
1090 CREATE TABLE collate_dep_test1 (a int, b text COLLATE test0);
1091 CREATE DOMAIN collate_dep_dom1 AS text COLLATE test0;
1092 CREATE TYPE collate_dep_test2 AS (x int, y text COLLATE test0);
1093 CREATE VIEW collate_dep_test3 AS SELECT text 'foo' COLLATE test0 AS foo;
1094 CREATE TABLE collate_dep_test4t (a int, b text);
1095 CREATE INDEX collate_dep_test4i ON collate_dep_test4t (b COLLATE test0);
1096 DROP COLLATION test0 RESTRICT; -- fail
1097 ERROR:  cannot drop collation test0 because other objects depend on it
1098 DETAIL:  column b of table collate_dep_test1 depends on collation test0
1099 type collate_dep_dom1 depends on collation test0
1100 column y of composite type collate_dep_test2 depends on collation test0
1101 view collate_dep_test3 depends on collation test0
1102 index collate_dep_test4i depends on collation test0
1103 HINT:  Use DROP ... CASCADE to drop the dependent objects too.
1104 DROP COLLATION test0 CASCADE;
1105 NOTICE:  drop cascades to 5 other objects
1106 DETAIL:  drop cascades to column b of table collate_dep_test1
1107 drop cascades to type collate_dep_dom1
1108 drop cascades to column y of composite type collate_dep_test2
1109 drop cascades to view collate_dep_test3
1110 drop cascades to index collate_dep_test4i
1111 \d collate_dep_test1
1112       Table "collate_tests.collate_dep_test1"
1113  Column |  Type   | Collation | Nullable | Default
1114 --------+---------+-----------+----------+---------
1115  a      | integer |           |          |
1116
1117 \d collate_dep_test2
1118  Composite type "collate_tests.collate_dep_test2"
1119  Column |  Type   | Collation | Nullable | Default
1120 --------+---------+-----------+----------+---------
1121  x      | integer |           |          |
1122
1123 DROP TABLE collate_dep_test1, collate_dep_test4t;
1124 DROP TYPE collate_dep_test2;
1125 -- test range types and collations
1126 create type textrange_c as range(subtype=text, collation="C");
1127 create type textrange_en_us as range(subtype=text, collation="en-x-icu");
1128 select textrange_c('A','Z') @> 'b'::text;
1129  ?column?
1130 ----------
1131  f
1132 (1 row)
1133
1134 select textrange_en_us('A','Z') @> 'b'::text;
1135  ?column?
1136 ----------
1137  t
1138 (1 row)
1139
1140 drop type textrange_c;
1141 drop type textrange_en_us;
1142 -- test ICU collation customization
1143 -- test the attributes handled by icu_set_collation_attributes()
1144 CREATE COLLATION testcoll_ignore_accents (provider = icu, locale = '@colStrength=primary;colCaseLevel=yes');
1145 SELECT 'aaá' > 'AAA' COLLATE "und-x-icu", 'aaá' < 'AAA' COLLATE testcoll_ignore_accents;
1146  ?column? | ?column?
1147 ----------+----------
1148  t        | t
1149 (1 row)
1150
1151 CREATE COLLATION testcoll_backwards (provider = icu, locale = '@colBackwards=yes');
1152 SELECT 'coté' < 'côte' COLLATE "und-x-icu", 'coté' > 'côte' COLLATE testcoll_backwards;
1153  ?column? | ?column?
1154 ----------+----------
1155  t        | t
1156 (1 row)
1157
1158 CREATE COLLATION testcoll_lower_first (provider = icu, locale = '@colCaseFirst=lower');
1159 CREATE COLLATION testcoll_upper_first (provider = icu, locale = '@colCaseFirst=upper');
1160 SELECT 'aaa' < 'AAA' COLLATE testcoll_lower_first, 'aaa' > 'AAA' COLLATE testcoll_upper_first;
1161  ?column? | ?column?
1162 ----------+----------
1163  t        | t
1164 (1 row)
1165
1166 CREATE COLLATION testcoll_shifted (provider = icu, locale = '@colAlternate=shifted');
1167 SELECT 'de-luge' < 'deanza' COLLATE "und-x-icu", 'de-luge' > 'deanza' COLLATE testcoll_shifted;
1168  ?column? | ?column?
1169 ----------+----------
1170  t        | t
1171 (1 row)
1172
1173 CREATE COLLATION testcoll_numeric (provider = icu, locale = '@colNumeric=yes');
1174 SELECT 'A-21' > 'A-123' COLLATE "und-x-icu", 'A-21' < 'A-123' COLLATE testcoll_numeric;
1175  ?column? | ?column?
1176 ----------+----------
1177  t        | t
1178 (1 row)
1179
1180 CREATE COLLATION testcoll_error1 (provider = icu, locale = '@colNumeric=lower');
1181 ERROR:  could not open collator for locale "@colNumeric=lower": U_ILLEGAL_ARGUMENT_ERROR
1182 -- test that attributes not handled by icu_set_collation_attributes()
1183 -- (handled by ucol_open() directly) also work
1184 CREATE COLLATION testcoll_de_phonebook (provider = icu, locale = 'de@collation=phonebook');
1185 SELECT 'Goldmann' < 'Götz' COLLATE "de-x-icu", 'Goldmann' > 'Götz' COLLATE testcoll_de_phonebook;
1186  ?column? | ?column?
1187 ----------+----------
1188  t        | t
1189 (1 row)
1190
1191 -- nondeterministic collations
1192 CREATE COLLATION ctest_det (provider = icu, locale = '', deterministic = true);
1193 CREATE COLLATION ctest_nondet (provider = icu, locale = '', deterministic = false);
1194 CREATE TABLE test6 (a int, b text);
1195 -- same string in different normal forms
1196 INSERT INTO test6 VALUES (1, U&'\00E4bc');
1197 INSERT INTO test6 VALUES (2, U&'\0061\0308bc');
1198 SELECT * FROM test6;
1199  a |  b
1200 ---+-----
1201  1 | äbc
1202  2 | äbc
1203 (2 rows)
1204
1205 SELECT * FROM test6 WHERE b = 'äbc' COLLATE ctest_det;
1206  a |  b
1207 ---+-----
1208  1 | äbc
1209 (1 row)
1210
1211 SELECT * FROM test6 WHERE b = 'äbc' COLLATE ctest_nondet;
1212  a |  b
1213 ---+-----
1214  1 | äbc
1215  2 | äbc
1216 (2 rows)
1217
1218 -- same with arrays
1219 CREATE TABLE test6a (a int, b text[]);
1220 INSERT INTO test6a VALUES (1, ARRAY[U&'\00E4bc']);
1221 INSERT INTO test6a VALUES (2, ARRAY[U&'\0061\0308bc']);
1222 SELECT * FROM test6a;
1223  a |   b
1224 ---+-------
1225  1 | {äbc}
1226  2 | {äbc}
1227 (2 rows)
1228
1229 SELECT * FROM test6a WHERE b = ARRAY['äbc'] COLLATE ctest_det;
1230  a |   b
1231 ---+-------
1232  1 | {äbc}
1233 (1 row)
1234
1235 SELECT * FROM test6a WHERE b = ARRAY['äbc'] COLLATE ctest_nondet;
1236  a |   b
1237 ---+-------
1238  1 | {äbc}
1239  2 | {äbc}
1240 (2 rows)
1241
1242 CREATE COLLATION case_sensitive (provider = icu, locale = '');
1243 CREATE COLLATION case_insensitive (provider = icu, locale = '@colStrength=secondary', deterministic = false);
1244 SELECT 'abc' <= 'ABC' COLLATE case_sensitive, 'abc' >= 'ABC' COLLATE case_sensitive;
1245  ?column? | ?column?
1246 ----------+----------
1247  t        | f
1248 (1 row)
1249
1250 SELECT 'abc' <= 'ABC' COLLATE case_insensitive, 'abc' >= 'ABC' COLLATE case_insensitive;
1251  ?column? | ?column?
1252 ----------+----------
1253  t        | t
1254 (1 row)
1255
1256 CREATE TABLE test1cs (x text COLLATE case_sensitive);
1257 CREATE TABLE test2cs (x text COLLATE case_sensitive);
1258 CREATE TABLE test3cs (x text COLLATE case_sensitive);
1259 INSERT INTO test1cs VALUES ('abc'), ('def'), ('ghi');
1260 INSERT INTO test2cs VALUES ('ABC'), ('ghi');
1261 INSERT INTO test3cs VALUES ('abc'), ('ABC'), ('def'), ('ghi');
1262 SELECT x FROM test3cs WHERE x = 'abc';
1263   x
1264 -----
1265  abc
1266 (1 row)
1267
1268 SELECT x FROM test3cs WHERE x <> 'abc';
1269   x
1270 -----
1271  ABC
1272  def
1273  ghi
1274 (3 rows)
1275
1276 SELECT x FROM test3cs WHERE x LIKE 'a%';
1277   x
1278 -----
1279  abc
1280 (1 row)
1281
1282 SELECT x FROM test3cs WHERE x ILIKE 'a%';
1283   x
1284 -----
1285  abc
1286  ABC
1287 (2 rows)
1288
1289 SELECT x FROM test3cs WHERE x SIMILAR TO 'a%';
1290   x
1291 -----
1292  abc
1293 (1 row)
1294
1295 SELECT x FROM test3cs WHERE x ~ 'a';
1296   x
1297 -----
1298  abc
1299 (1 row)
1300
1301 SELECT x FROM test1cs UNION SELECT x FROM test2cs ORDER BY x;
1302   x
1303 -----
1304  abc
1305  ABC
1306  def
1307  ghi
1308 (4 rows)
1309
1310 SELECT x FROM test2cs UNION SELECT x FROM test1cs ORDER BY x;
1311   x
1312 -----
1313  abc
1314  ABC
1315  def
1316  ghi
1317 (4 rows)
1318
1319 SELECT x FROM test1cs INTERSECT SELECT x FROM test2cs;
1320   x
1321 -----
1322  ghi
1323 (1 row)
1324
1325 SELECT x FROM test2cs INTERSECT SELECT x FROM test1cs;
1326   x
1327 -----
1328  ghi
1329 (1 row)
1330
1331 SELECT x FROM test1cs EXCEPT SELECT x FROM test2cs;
1332   x
1333 -----
1334  abc
1335  def
1336 (2 rows)
1337
1338 SELECT x FROM test2cs EXCEPT SELECT x FROM test1cs;
1339   x
1340 -----
1341  ABC
1342 (1 row)
1343
1344 SELECT DISTINCT x FROM test3cs ORDER BY x;
1345   x
1346 -----
1347  abc
1348  ABC
1349  def
1350  ghi
1351 (4 rows)
1352
1353 SELECT count(DISTINCT x) FROM test3cs;
1354  count
1355 -------
1356      4
1357 (1 row)
1358
1359 SELECT x, count(*) FROM test3cs GROUP BY x ORDER BY x;
1360   x  | count
1361 -----+-------
1362  abc |     1
1363  ABC |     1
1364  def |     1
1365  ghi |     1
1366 (4 rows)
1367
1368 SELECT x, row_number() OVER (ORDER BY x), rank() OVER (ORDER BY x) FROM test3cs ORDER BY x;
1369   x  | row_number | rank
1370 -----+------------+------
1371  abc |          1 |    1
1372  ABC |          2 |    2
1373  def |          3 |    3
1374  ghi |          4 |    4
1375 (4 rows)
1376
1377 CREATE UNIQUE INDEX ON test1cs (x);  -- ok
1378 INSERT INTO test1cs VALUES ('ABC');  -- ok
1379 CREATE UNIQUE INDEX ON test3cs (x);  -- ok
1380 SELECT string_to_array('ABC,DEF,GHI' COLLATE case_sensitive, ',', 'abc');
1381  string_to_array
1382 -----------------
1383  {ABC,DEF,GHI}
1384 (1 row)
1385
1386 SELECT string_to_array('ABCDEFGHI' COLLATE case_sensitive, NULL, 'b');
1387    string_to_array
1388 ---------------------
1389  {A,B,C,D,E,F,G,H,I}
1390 (1 row)
1391
1392 CREATE TABLE test1ci (x text COLLATE case_insensitive);
1393 CREATE TABLE test2ci (x text COLLATE case_insensitive);
1394 CREATE TABLE test3ci (x text COLLATE case_insensitive);
1395 CREATE INDEX ON test3ci (x text_pattern_ops);  -- error
1396 ERROR:  nondeterministic collations are not supported for operator class "text_pattern_ops"
1397 INSERT INTO test1ci VALUES ('abc'), ('def'), ('ghi');
1398 INSERT INTO test2ci VALUES ('ABC'), ('ghi');
1399 INSERT INTO test3ci VALUES ('abc'), ('ABC'), ('def'), ('ghi');
1400 SELECT x FROM test3ci WHERE x = 'abc';
1401   x
1402 -----
1403  abc
1404  ABC
1405 (2 rows)
1406
1407 SELECT x FROM test3ci WHERE x <> 'abc';
1408   x
1409 -----
1410  def
1411  ghi
1412 (2 rows)
1413
1414 SELECT x FROM test3ci WHERE x LIKE 'a%';
1415 ERROR:  nondeterministic collations are not supported for LIKE
1416 SELECT x FROM test3ci WHERE x ILIKE 'a%';
1417 ERROR:  nondeterministic collations are not supported for ILIKE
1418 SELECT x FROM test3ci WHERE x SIMILAR TO 'a%';
1419 ERROR:  nondeterministic collations are not supported for regular expressions
1420 SELECT x FROM test3ci WHERE x ~ 'a';
1421 ERROR:  nondeterministic collations are not supported for regular expressions
1422 SELECT x FROM test1ci UNION SELECT x FROM test2ci ORDER BY x;
1423   x
1424 -----
1425  abc
1426  def
1427  ghi
1428 (3 rows)
1429
1430 SELECT x FROM test2ci UNION SELECT x FROM test1ci ORDER BY x;
1431   x
1432 -----
1433  ABC
1434  def
1435  ghi
1436 (3 rows)
1437
1438 SELECT x FROM test1ci INTERSECT SELECT x FROM test2ci ORDER BY x;
1439   x
1440 -----
1441  abc
1442  ghi
1443 (2 rows)
1444
1445 SELECT x FROM test2ci INTERSECT SELECT x FROM test1ci ORDER BY x;
1446   x
1447 -----
1448  ABC
1449  ghi
1450 (2 rows)
1451
1452 SELECT x FROM test1ci EXCEPT SELECT x FROM test2ci;
1453   x
1454 -----
1455  def
1456 (1 row)
1457
1458 SELECT x FROM test2ci EXCEPT SELECT x FROM test1ci;
1459  x
1460 ---
1461 (0 rows)
1462
1463 SELECT DISTINCT x FROM test3ci ORDER BY x;
1464   x
1465 -----
1466  abc
1467  def
1468  ghi
1469 (3 rows)
1470
1471 SELECT count(DISTINCT x) FROM test3ci;
1472  count
1473 -------
1474      3
1475 (1 row)
1476
1477 SELECT x, count(*) FROM test3ci GROUP BY x ORDER BY x;
1478   x  | count
1479 -----+-------
1480  abc |     2
1481  def |     1
1482  ghi |     1
1483 (3 rows)
1484
1485 SELECT x, row_number() OVER (ORDER BY x), rank() OVER (ORDER BY x) FROM test3ci ORDER BY x;
1486   x  | row_number | rank
1487 -----+------------+------
1488  abc |          1 |    1
1489  ABC |          2 |    1
1490  def |          3 |    3
1491  ghi |          4 |    4
1492 (4 rows)
1493
1494 CREATE UNIQUE INDEX ON test1ci (x);  -- ok
1495 INSERT INTO test1ci VALUES ('ABC');  -- error
1496 ERROR:  duplicate key value violates unique constraint "test1ci_x_idx"
1497 DETAIL:  Key (x)=(ABC) already exists.
1498 CREATE UNIQUE INDEX ON test3ci (x);  -- error
1499 ERROR:  could not create unique index "test3ci_x_idx"
1500 DETAIL:  Key (x)=(abc) is duplicated.
1501 SELECT string_to_array('ABC,DEF,GHI' COLLATE case_insensitive, ',', 'abc');
1502 ERROR:  nondeterministic collations are not supported for substring searches
1503 SELECT string_to_array('ABCDEFGHI' COLLATE case_insensitive, NULL, 'b');
1504     string_to_array
1505 ------------------------
1506  {A,NULL,C,D,E,F,G,H,I}
1507 (1 row)
1508
1509 -- bpchar
1510 CREATE TABLE test1bpci (x char(3) COLLATE case_insensitive);
1511 CREATE TABLE test2bpci (x char(3) COLLATE case_insensitive);
1512 CREATE TABLE test3bpci (x char(3) COLLATE case_insensitive);
1513 CREATE INDEX ON test3bpci (x bpchar_pattern_ops);  -- error
1514 ERROR:  nondeterministic collations are not supported for operator class "bpchar_pattern_ops"
1515 INSERT INTO test1bpci VALUES ('abc'), ('def'), ('ghi');
1516 INSERT INTO test2bpci VALUES ('ABC'), ('ghi');
1517 INSERT INTO test3bpci VALUES ('abc'), ('ABC'), ('def'), ('ghi');
1518 SELECT x FROM test3bpci WHERE x = 'abc';
1519   x
1520 -----
1521  abc
1522  ABC
1523 (2 rows)
1524
1525 SELECT x FROM test3bpci WHERE x <> 'abc';
1526   x
1527 -----
1528  def
1529  ghi
1530 (2 rows)
1531
1532 SELECT x FROM test3bpci WHERE x LIKE 'a%';
1533 ERROR:  nondeterministic collations are not supported for LIKE
1534 SELECT x FROM test3bpci WHERE x ILIKE 'a%';
1535 ERROR:  nondeterministic collations are not supported for ILIKE
1536 SELECT x FROM test3bpci WHERE x SIMILAR TO 'a%';
1537 ERROR:  nondeterministic collations are not supported for regular expressions
1538 SELECT x FROM test3bpci WHERE x ~ 'a';
1539 ERROR:  nondeterministic collations are not supported for regular expressions
1540 SELECT x FROM test1bpci UNION SELECT x FROM test2bpci ORDER BY x;
1541   x
1542 -----
1543  abc
1544  def
1545  ghi
1546 (3 rows)
1547
1548 SELECT x FROM test2bpci UNION SELECT x FROM test1bpci ORDER BY x;
1549   x
1550 -----
1551  ABC
1552  def
1553  ghi
1554 (3 rows)
1555
1556 SELECT x FROM test1bpci INTERSECT SELECT x FROM test2bpci ORDER BY x;
1557   x
1558 -----
1559  abc
1560  ghi
1561 (2 rows)
1562
1563 SELECT x FROM test2bpci INTERSECT SELECT x FROM test1bpci ORDER BY x;
1564   x
1565 -----
1566  ABC
1567  ghi
1568 (2 rows)
1569
1570 SELECT x FROM test1bpci EXCEPT SELECT x FROM test2bpci;
1571   x
1572 -----
1573  def
1574 (1 row)
1575
1576 SELECT x FROM test2bpci EXCEPT SELECT x FROM test1bpci;
1577  x
1578 ---
1579 (0 rows)
1580
1581 SELECT DISTINCT x FROM test3bpci ORDER BY x;
1582   x
1583 -----
1584  abc
1585  def
1586  ghi
1587 (3 rows)
1588
1589 SELECT count(DISTINCT x) FROM test3bpci;
1590  count
1591 -------
1592      3
1593 (1 row)
1594
1595 SELECT x, count(*) FROM test3bpci GROUP BY x ORDER BY x;
1596   x  | count
1597 -----+-------
1598  abc |     2
1599  def |     1
1600  ghi |     1
1601 (3 rows)
1602
1603 SELECT x, row_number() OVER (ORDER BY x), rank() OVER (ORDER BY x) FROM test3bpci ORDER BY x;
1604   x  | row_number | rank
1605 -----+------------+------
1606  abc |          1 |    1
1607  ABC |          2 |    1
1608  def |          3 |    3
1609  ghi |          4 |    4
1610 (4 rows)
1611
1612 CREATE UNIQUE INDEX ON test1bpci (x);  -- ok
1613 INSERT INTO test1bpci VALUES ('ABC');  -- error
1614 ERROR:  duplicate key value violates unique constraint "test1bpci_x_idx"
1615 DETAIL:  Key (x)=(ABC) already exists.
1616 CREATE UNIQUE INDEX ON test3bpci (x);  -- error
1617 ERROR:  could not create unique index "test3bpci_x_idx"
1618 DETAIL:  Key (x)=(abc) is duplicated.
1619 SELECT string_to_array('ABC,DEF,GHI'::char(11) COLLATE case_insensitive, ',', 'abc');
1620 ERROR:  nondeterministic collations are not supported for substring searches
1621 SELECT string_to_array('ABCDEFGHI'::char(9) COLLATE case_insensitive, NULL, 'b');
1622     string_to_array
1623 ------------------------
1624  {A,NULL,C,D,E,F,G,H,I}
1625 (1 row)
1626
1627 -- This tests the issue described in match_pattern_prefix().  In the
1628 -- absence of that check, the case_insensitive tests below would
1629 -- return no rows where they should logically return one.
1630 CREATE TABLE test4c (x text COLLATE "C");
1631 INSERT INTO test4c VALUES ('abc');
1632 CREATE INDEX ON test4c (x);
1633 SET enable_seqscan = off;
1634 SELECT x FROM test4c WHERE x LIKE 'ABC' COLLATE case_sensitive;  -- ok, no rows
1635  x
1636 ---
1637 (0 rows)
1638
1639 SELECT x FROM test4c WHERE x LIKE 'ABC%' COLLATE case_sensitive;  -- ok, no rows
1640  x
1641 ---
1642 (0 rows)
1643
1644 SELECT x FROM test4c WHERE x LIKE 'ABC' COLLATE case_insensitive;  -- error
1645 ERROR:  nondeterministic collations are not supported for LIKE
1646 SELECT x FROM test4c WHERE x LIKE 'ABC%' COLLATE case_insensitive;  -- error
1647 ERROR:  nondeterministic collations are not supported for LIKE
1648 RESET enable_seqscan;
1649 -- Unicode special case: different variants of Greek lower case sigma.
1650 -- A naive implementation like citext that just does lower(x) =
1651 -- lower(y) will do the wrong thing here, because lower('Σ') is 'σ'
1652 -- but upper('ς') is 'Σ'.
1653 SELECT 'ὀδυσσεύς' = 'ὈΔΥΣΣΕΎΣ' COLLATE case_sensitive;
1654  ?column?
1655 ----------
1656  f
1657 (1 row)
1658
1659 SELECT 'ὀδυσσεύς' = 'ὈΔΥΣΣΕΎΣ' COLLATE case_insensitive;
1660  ?column?
1661 ----------
1662  t
1663 (1 row)
1664
1665 -- name vs. text comparison operators
1666 SELECT relname FROM pg_class WHERE relname = 'PG_CLASS'::text COLLATE case_insensitive;
1667  relname
1668 ----------
1669  pg_class
1670 (1 row)
1671
1672 SELECT relname FROM pg_class WHERE 'PG_CLASS'::text = relname COLLATE case_insensitive;
1673  relname
1674 ----------
1675  pg_class
1676 (1 row)
1677
1678 SELECT typname FROM pg_type WHERE typname LIKE 'int_' AND typname <> 'INT2'::text
1679   COLLATE case_insensitive ORDER BY typname;
1680  typname
1681 ---------
1682  int4
1683  int8
1684 (2 rows)
1685
1686 SELECT typname FROM pg_type WHERE typname LIKE 'int_' AND 'INT2'::text <> typname
1687   COLLATE case_insensitive ORDER BY typname;
1688  typname
1689 ---------
1690  int4
1691  int8
1692 (2 rows)
1693
1694 -- test case adapted from subselect.sql
1695 CREATE TEMP TABLE outer_text (f1 text COLLATE case_insensitive, f2 text);
1696 INSERT INTO outer_text VALUES ('a', 'a');
1697 INSERT INTO outer_text VALUES ('b', 'a');
1698 INSERT INTO outer_text VALUES ('A', NULL);
1699 INSERT INTO outer_text VALUES ('B', NULL);
1700 CREATE TEMP TABLE inner_text (c1 text COLLATE case_insensitive, c2 text);
1701 INSERT INTO inner_text VALUES ('a', NULL);
1702 SELECT * FROM outer_text WHERE (f1, f2) NOT IN (SELECT * FROM inner_text);
1703  f1 | f2
1704 ----+----
1705  b  | a
1706  B  |
1707 (2 rows)
1708
1709 -- accents
1710 CREATE COLLATION ignore_accents (provider = icu, locale = '@colStrength=primary;colCaseLevel=yes', deterministic = false);
1711 CREATE TABLE test4 (a int, b text);
1712 INSERT INTO test4 VALUES (1, 'cote'), (2, 'côte'), (3, 'coté'), (4, 'côté');
1713 SELECT * FROM test4 WHERE b = 'cote';
1714  a |  b
1715 ---+------
1716  1 | cote
1717 (1 row)
1718
1719 SELECT * FROM test4 WHERE b = 'cote' COLLATE ignore_accents;
1720  a |  b
1721 ---+------
1722  1 | cote
1723  2 | côte
1724  3 | coté
1725  4 | côté
1726 (4 rows)
1727
1728 SELECT * FROM test4 WHERE b = 'Cote' COLLATE ignore_accents;  -- still case-sensitive
1729  a | b
1730 ---+---
1731 (0 rows)
1732
1733 SELECT * FROM test4 WHERE b = 'Cote' COLLATE case_insensitive;
1734  a |  b
1735 ---+------
1736  1 | cote
1737 (1 row)
1738
1739 -- foreign keys (should use collation of primary key)
1740 -- PK is case-sensitive, FK is case-insensitive
1741 CREATE TABLE test10pk (x text COLLATE case_sensitive PRIMARY KEY);
1742 INSERT INTO test10pk VALUES ('abc'), ('def'), ('ghi');
1743 CREATE TABLE test10fk (x text COLLATE case_insensitive REFERENCES test10pk (x) ON UPDATE CASCADE ON DELETE CASCADE);
1744 INSERT INTO test10fk VALUES ('abc');  -- ok
1745 INSERT INTO test10fk VALUES ('ABC');  -- error
1746 ERROR:  insert or update on table "test10fk" violates foreign key constraint "test10fk_x_fkey"
1747 DETAIL:  Key (x)=(ABC) is not present in table "test10pk".
1748 INSERT INTO test10fk VALUES ('xyz');  -- error
1749 ERROR:  insert or update on table "test10fk" violates foreign key constraint "test10fk_x_fkey"
1750 DETAIL:  Key (x)=(xyz) is not present in table "test10pk".
1751 SELECT * FROM test10pk;
1752   x
1753 -----
1754  abc
1755  def
1756  ghi
1757 (3 rows)
1758
1759 SELECT * FROM test10fk;
1760   x
1761 -----
1762  abc
1763 (1 row)
1764
1765 -- restrict update even though the values are "equal" in the FK table
1766 UPDATE test10fk SET x = 'ABC' WHERE x = 'abc';  -- error
1767 ERROR:  insert or update on table "test10fk" violates foreign key constraint "test10fk_x_fkey"
1768 DETAIL:  Key (x)=(ABC) is not present in table "test10pk".
1769 SELECT * FROM test10fk;
1770   x
1771 -----
1772  abc
1773 (1 row)
1774
1775 DELETE FROM test10pk WHERE x = 'abc';
1776 SELECT * FROM test10pk;
1777   x
1778 -----
1779  def
1780  ghi
1781 (2 rows)
1782
1783 SELECT * FROM test10fk;
1784  x
1785 ---
1786 (0 rows)
1787
1788 -- PK is case-insensitive, FK is case-sensitive
1789 CREATE TABLE test11pk (x text COLLATE case_insensitive PRIMARY KEY);
1790 INSERT INTO test11pk VALUES ('abc'), ('def'), ('ghi');
1791 CREATE TABLE test11fk (x text COLLATE case_sensitive REFERENCES test11pk (x) ON UPDATE CASCADE ON DELETE CASCADE);
1792 INSERT INTO test11fk VALUES ('abc');  -- ok
1793 INSERT INTO test11fk VALUES ('ABC');  -- ok
1794 INSERT INTO test11fk VALUES ('xyz');  -- error
1795 ERROR:  insert or update on table "test11fk" violates foreign key constraint "test11fk_x_fkey"
1796 DETAIL:  Key (x)=(xyz) is not present in table "test11pk".
1797 SELECT * FROM test11pk;
1798   x
1799 -----
1800  abc
1801  def
1802  ghi
1803 (3 rows)
1804
1805 SELECT * FROM test11fk;
1806   x
1807 -----
1808  abc
1809  ABC
1810 (2 rows)
1811
1812 -- cascade update even though the values are "equal" in the PK table
1813 UPDATE test11pk SET x = 'ABC' WHERE x = 'abc';
1814 SELECT * FROM test11fk;
1815   x
1816 -----
1817  ABC
1818  ABC
1819 (2 rows)
1820
1821 DELETE FROM test11pk WHERE x = 'abc';
1822 SELECT * FROM test11pk;
1823   x
1824 -----
1825  def
1826  ghi
1827 (2 rows)
1828
1829 SELECT * FROM test11fk;
1830  x
1831 ---
1832 (0 rows)
1833
1834 -- partitioning
1835 CREATE TABLE test20 (a int, b text COLLATE case_insensitive) PARTITION BY LIST (b);
1836 CREATE TABLE test20_1 PARTITION OF test20 FOR VALUES IN ('abc');
1837 INSERT INTO test20 VALUES (1, 'abc');
1838 INSERT INTO test20 VALUES (2, 'ABC');
1839 SELECT * FROM test20_1;
1840  a |  b
1841 ---+-----
1842  1 | abc
1843  2 | ABC
1844 (2 rows)
1845
1846 CREATE TABLE test21 (a int, b text COLLATE case_insensitive) PARTITION BY RANGE (b);
1847 CREATE TABLE test21_1 PARTITION OF test21 FOR VALUES FROM ('ABC') TO ('DEF');
1848 INSERT INTO test21 VALUES (1, 'abc');
1849 INSERT INTO test21 VALUES (2, 'ABC');
1850 SELECT * FROM test21_1;
1851  a |  b
1852 ---+-----
1853  1 | abc
1854  2 | ABC
1855 (2 rows)
1856
1857 CREATE TABLE test22 (a int, b text COLLATE case_sensitive) PARTITION BY HASH (b);
1858 CREATE TABLE test22_0 PARTITION OF test22 FOR VALUES WITH (MODULUS 2, REMAINDER 0);
1859 CREATE TABLE test22_1 PARTITION OF test22 FOR VALUES WITH (MODULUS 2, REMAINDER 1);
1860 INSERT INTO test22 VALUES (1, 'def');
1861 INSERT INTO test22 VALUES (2, 'DEF');
1862 -- they end up in different partitions
1863 SELECT (SELECT count(*) FROM test22_0) = (SELECT count(*) FROM test22_1);
1864  ?column?
1865 ----------
1866  t
1867 (1 row)
1868
1869 -- same with arrays
1870 CREATE TABLE test22a (a int, b text[] COLLATE case_sensitive) PARTITION BY HASH (b);
1871 CREATE TABLE test22a_0 PARTITION OF test22a FOR VALUES WITH (MODULUS 2, REMAINDER 0);
1872 CREATE TABLE test22a_1 PARTITION OF test22a FOR VALUES WITH (MODULUS 2, REMAINDER 1);
1873 INSERT INTO test22a VALUES (1, ARRAY['def']);
1874 INSERT INTO test22a VALUES (2, ARRAY['DEF']);
1875 -- they end up in different partitions
1876 SELECT (SELECT count(*) FROM test22a_0) = (SELECT count(*) FROM test22a_1);
1877  ?column?
1878 ----------
1879  t
1880 (1 row)
1881
1882 CREATE TABLE test23 (a int, b text COLLATE case_insensitive) PARTITION BY HASH (b);
1883 CREATE TABLE test23_0 PARTITION OF test23 FOR VALUES WITH (MODULUS 2, REMAINDER 0);
1884 CREATE TABLE test23_1 PARTITION OF test23 FOR VALUES WITH (MODULUS 2, REMAINDER 1);
1885 INSERT INTO test23 VALUES (1, 'def');
1886 INSERT INTO test23 VALUES (2, 'DEF');
1887 -- they end up in the same partition (but it's platform-dependent which one)
1888 SELECT (SELECT count(*) FROM test23_0) <> (SELECT count(*) FROM test23_1);
1889  ?column?
1890 ----------
1891  t
1892 (1 row)
1893
1894 -- same with arrays
1895 CREATE TABLE test23a (a int, b text[] COLLATE case_insensitive) PARTITION BY HASH (b);
1896 CREATE TABLE test23a_0 PARTITION OF test23a FOR VALUES WITH (MODULUS 2, REMAINDER 0);
1897 CREATE TABLE test23a_1 PARTITION OF test23a FOR VALUES WITH (MODULUS 2, REMAINDER 1);
1898 INSERT INTO test23a VALUES (1, ARRAY['def']);
1899 INSERT INTO test23a VALUES (2, ARRAY['DEF']);
1900 -- they end up in the same partition (but it's platform-dependent which one)
1901 SELECT (SELECT count(*) FROM test23a_0) <> (SELECT count(*) FROM test23a_1);
1902  ?column?
1903 ----------
1904  t
1905 (1 row)
1906
1907 CREATE TABLE test30 (a int, b char(3) COLLATE case_insensitive) PARTITION BY LIST (b);
1908 CREATE TABLE test30_1 PARTITION OF test30 FOR VALUES IN ('abc');
1909 INSERT INTO test30 VALUES (1, 'abc');
1910 INSERT INTO test30 VALUES (2, 'ABC');
1911 SELECT * FROM test30_1;
1912  a |  b
1913 ---+-----
1914  1 | abc
1915  2 | ABC
1916 (2 rows)
1917
1918 CREATE TABLE test31 (a int, b char(3) COLLATE case_insensitive) PARTITION BY RANGE (b);
1919 CREATE TABLE test31_1 PARTITION OF test31 FOR VALUES FROM ('ABC') TO ('DEF');
1920 INSERT INTO test31 VALUES (1, 'abc');
1921 INSERT INTO test31 VALUES (2, 'ABC');
1922 SELECT * FROM test31_1;
1923  a |  b
1924 ---+-----
1925  1 | abc
1926  2 | ABC
1927 (2 rows)
1928
1929 CREATE TABLE test32 (a int, b char(3) COLLATE case_sensitive) PARTITION BY HASH (b);
1930 CREATE TABLE test32_0 PARTITION OF test32 FOR VALUES WITH (MODULUS 2, REMAINDER 0);
1931 CREATE TABLE test32_1 PARTITION OF test32 FOR VALUES WITH (MODULUS 2, REMAINDER 1);
1932 INSERT INTO test32 VALUES (1, 'def');
1933 INSERT INTO test32 VALUES (2, 'DEF');
1934 -- they end up in different partitions
1935 SELECT (SELECT count(*) FROM test32_0) = (SELECT count(*) FROM test32_1);
1936  ?column?
1937 ----------
1938  t
1939 (1 row)
1940
1941 CREATE TABLE test33 (a int, b char(3) COLLATE case_insensitive) PARTITION BY HASH (b);
1942 CREATE TABLE test33_0 PARTITION OF test33 FOR VALUES WITH (MODULUS 2, REMAINDER 0);
1943 CREATE TABLE test33_1 PARTITION OF test33 FOR VALUES WITH (MODULUS 2, REMAINDER 1);
1944 INSERT INTO test33 VALUES (1, 'def');
1945 INSERT INTO test33 VALUES (2, 'DEF');
1946 -- they end up in the same partition (but it's platform-dependent which one)
1947 SELECT (SELECT count(*) FROM test33_0) <> (SELECT count(*) FROM test33_1);
1948  ?column?
1949 ----------
1950  t
1951 (1 row)
1952
1953 -- cleanup
1954 RESET search_path;
1955 SET client_min_messages TO warning;
1956 DROP SCHEMA collate_tests CASCADE;
1957 RESET client_min_messages;
1958 -- leave a collation for pg_upgrade test
1959 CREATE COLLATION coll_icu_upgrade FROM "und-x-icu";