src/test/regress/expected/enum.out

   1 --
   2 -- Enum tests
   3 --
   4 CREATE TYPE rainbow AS ENUM ('red', 'orange', 'yellow', 'green', 'blue', 'purple');
   5 --
   6 -- Did it create the right number of rows?
   7 --
   8 SELECT COUNT(*) FROM pg_enum WHERE enumtypid = 'rainbow'::regtype;
   9  count
  10 -------
  11      6
  12 (1 row)
  13
  14 --
  15 -- I/O functions
  16 --
  17 SELECT 'red'::rainbow;
  18  rainbow
  19 ---------
  20  red
  21 (1 row)
  22
  23 SELECT 'mauve'::rainbow;
  24 ERROR:  invalid input value for enum rainbow: "mauve"
  25 LINE 1: SELECT 'mauve'::rainbow;
  26                ^
  27 --
  28 -- adding new values
  29 --
  30 CREATE TYPE planets AS ENUM ( 'venus', 'earth', 'mars' );
  31 SELECT enumlabel, enumsortorder
  32 FROM pg_enum
  33 WHERE enumtypid = 'planets'::regtype
  34 ORDER BY 2;
  35  enumlabel | enumsortorder
  36 -----------+---------------
  37  venus     |             1
  38  earth     |             2
  39  mars      |             3
  40 (3 rows)
  41
  42 ALTER TYPE planets ADD VALUE 'uranus';
  43 SELECT enumlabel, enumsortorder
  44 FROM pg_enum
  45 WHERE enumtypid = 'planets'::regtype
  46 ORDER BY 2;
  47  enumlabel | enumsortorder
  48 -----------+---------------
  49  venus     |             1
  50  earth     |             2
  51  mars      |             3
  52  uranus    |             4
  53 (4 rows)
  54
  55 ALTER TYPE planets ADD VALUE 'mercury' BEFORE 'venus';
  56 ALTER TYPE planets ADD VALUE 'saturn' BEFORE 'uranus';
  57 ALTER TYPE planets ADD VALUE 'jupiter' AFTER 'mars';
  58 ALTER TYPE planets ADD VALUE 'neptune' AFTER 'uranus';
  59 SELECT enumlabel, enumsortorder
  60 FROM pg_enum
  61 WHERE enumtypid = 'planets'::regtype
  62 ORDER BY 2;
  63  enumlabel | enumsortorder
  64 -----------+---------------
  65  mercury   |             0
  66  venus     |             1
  67  earth     |             2
  68  mars      |             3
  69  jupiter   |          3.25
  70  saturn    |           3.5
  71  uranus    |             4
  72  neptune   |             5
  73 (8 rows)
  74
  75 SELECT enumlabel, enumsortorder
  76 FROM pg_enum
  77 WHERE enumtypid = 'planets'::regtype
  78 ORDER BY enumlabel::planets;
  79  enumlabel | enumsortorder
  80 -----------+---------------
  81  mercury   |             0
  82  venus     |             1
  83  earth     |             2
  84  mars      |             3
  85  jupiter   |          3.25
  86  saturn    |           3.5
  87  uranus    |             4
  88  neptune   |             5
  89 (8 rows)
  90
  91 -- errors for adding labels
  92 ALTER TYPE planets ADD VALUE
  93   'plutoplutoplutoplutoplutoplutoplutoplutoplutoplutoplutoplutoplutopluto';
  94 ERROR:  invalid enum label "plutoplutoplutoplutoplutoplutoplutoplutoplutoplutoplutoplutoplutopluto"
  95 DETAIL:  Labels must be 63 bytes or less.
  96 ALTER TYPE planets ADD VALUE 'pluto' AFTER 'zeus';
  97 ERROR:  "zeus" is not an existing enum label
  98 -- if not exists tests
  99 --  existing value gives error
 100 ALTER TYPE planets ADD VALUE 'mercury';
 101 ERROR:  enum label "mercury" already exists
 102 -- unless IF NOT EXISTS is specified
 103 ALTER TYPE planets ADD VALUE IF NOT EXISTS 'mercury';
 104 NOTICE:  enum label "mercury" already exists, skipping
 105 -- should be neptune, not mercury
 106 SELECT enum_last(NULL::planets);
 107  enum_last
 108 -----------
 109  neptune
 110 (1 row)
 111
 112 ALTER TYPE planets ADD VALUE IF NOT EXISTS 'pluto';
 113 -- should be pluto, i.e. the new value
 114 SELECT enum_last(NULL::planets);
 115  enum_last
 116 -----------
 117  pluto
 118 (1 row)
 119
 120 --
 121 -- Test inserting so many values that we have to renumber
 122 --
 123 create type insenum as enum ('L1', 'L2');
 124 alter type insenum add value 'i1' before 'L2';
 125 alter type insenum add value 'i2' before 'L2';
 126 alter type insenum add value 'i3' before 'L2';
 127 alter type insenum add value 'i4' before 'L2';
 128 alter type insenum add value 'i5' before 'L2';
 129 alter type insenum add value 'i6' before 'L2';
 130 alter type insenum add value 'i7' before 'L2';
 131 alter type insenum add value 'i8' before 'L2';
 132 alter type insenum add value 'i9' before 'L2';
 133 alter type insenum add value 'i10' before 'L2';
 134 alter type insenum add value 'i11' before 'L2';
 135 alter type insenum add value 'i12' before 'L2';
 136 alter type insenum add value 'i13' before 'L2';
 137 alter type insenum add value 'i14' before 'L2';
 138 alter type insenum add value 'i15' before 'L2';
 139 alter type insenum add value 'i16' before 'L2';
 140 alter type insenum add value 'i17' before 'L2';
 141 alter type insenum add value 'i18' before 'L2';
 142 alter type insenum add value 'i19' before 'L2';
 143 alter type insenum add value 'i20' before 'L2';
 144 alter type insenum add value 'i21' before 'L2';
 145 alter type insenum add value 'i22' before 'L2';
 146 alter type insenum add value 'i23' before 'L2';
 147 alter type insenum add value 'i24' before 'L2';
 148 alter type insenum add value 'i25' before 'L2';
 149 alter type insenum add value 'i26' before 'L2';
 150 alter type insenum add value 'i27' before 'L2';
 151 alter type insenum add value 'i28' before 'L2';
 152 alter type insenum add value 'i29' before 'L2';
 153 alter type insenum add value 'i30' before 'L2';
 154 -- The exact values of enumsortorder will now depend on the local properties
 155 -- of float4, but in any reasonable implementation we should get at least
 156 -- 20 splits before having to renumber; so only hide values > 20.
 157 SELECT enumlabel,
 158        case when enumsortorder > 20 then null else enumsortorder end as so
 159 FROM pg_enum
 160 WHERE enumtypid = 'insenum'::regtype
 161 ORDER BY enumsortorder;
 162  enumlabel | so
 163 -----------+----
 164  L1        |  1
 165  i1        |  2
 166  i2        |  3
 167  i3        |  4
 168  i4        |  5
 169  i5        |  6
 170  i6        |  7
 171  i7        |  8
 172  i8        |  9
 173  i9        | 10
 174  i10       | 11
 175  i11       | 12
 176  i12       | 13
 177  i13       | 14
 178  i14       | 15
 179  i15       | 16
 180  i16       | 17
 181  i17       | 18
 182  i18       | 19
 183  i19       | 20
 184  i20       |
 185  i21       |
 186  i22       |
 187  i23       |
 188  i24       |
 189  i25       |
 190  i26       |
 191  i27       |
 192  i28       |
 193  i29       |
 194  i30       |
 195  L2        |
 196 (32 rows)
 197
 198 --
 199 -- Basic table creation, row selection
 200 --
 201 CREATE TABLE enumtest (col rainbow);
 202 INSERT INTO enumtest values ('red'), ('orange'), ('yellow'), ('green');
 203 COPY enumtest FROM stdin;
 204 SELECT * FROM enumtest;
 205   col
 206 --------
 207  red
 208  orange
 209  yellow
 210  green
 211  blue
 212  purple
 213 (6 rows)
 214
 215 --
 216 -- Operators, no index
 217 --
 218 SELECT * FROM enumtest WHERE col = 'orange';
 219   col
 220 --------
 221  orange
 222 (1 row)
 223
 224 SELECT * FROM enumtest WHERE col <> 'orange' ORDER BY col;
 225   col
 226 --------
 227  red
 228  yellow
 229  green
 230  blue
 231  purple
 232 (5 rows)
 233
 234 SELECT * FROM enumtest WHERE col > 'yellow' ORDER BY col;
 235   col
 236 --------
 237  green
 238  blue
 239  purple
 240 (3 rows)
 241
 242 SELECT * FROM enumtest WHERE col >= 'yellow' ORDER BY col;
 243   col
 244 --------
 245  yellow
 246  green
 247  blue
 248  purple
 249 (4 rows)
 250
 251 SELECT * FROM enumtest WHERE col < 'green' ORDER BY col;
 252   col
 253 --------
 254  red
 255  orange
 256  yellow
 257 (3 rows)
 258
 259 SELECT * FROM enumtest WHERE col <= 'green' ORDER BY col;
 260   col
 261 --------
 262  red
 263  orange
 264  yellow
 265  green
 266 (4 rows)
 267
 268 --
 269 -- Cast to/from text
 270 --
 271 SELECT 'red'::rainbow::text || 'hithere';
 272   ?column?
 273 ------------
 274  redhithere
 275 (1 row)
 276
 277 SELECT 'red'::text::rainbow = 'red'::rainbow;
 278  ?column?
 279 ----------
 280  t
 281 (1 row)
 282
 283 --
 284 -- Aggregates
 285 --
 286 SELECT min(col) FROM enumtest;
 287  min
 288 -----
 289  red
 290 (1 row)
 291
 292 SELECT max(col) FROM enumtest;
 293   max
 294 --------
 295  purple
 296 (1 row)
 297
 298 SELECT max(col) FROM enumtest WHERE col < 'green';
 299   max
 300 --------
 301  yellow
 302 (1 row)
 303
 304 --
 305 -- Index tests, force use of index
 306 --
 307 SET enable_seqscan = off;
 308 SET enable_bitmapscan = off;
 309 --
 310 -- Btree index / opclass with the various operators
 311 --
 312 CREATE UNIQUE INDEX enumtest_btree ON enumtest USING btree (col);
 313 SELECT * FROM enumtest WHERE col = 'orange';
 314   col
 315 --------
 316  orange
 317 (1 row)
 318
 319 SELECT * FROM enumtest WHERE col <> 'orange' ORDER BY col;
 320   col
 321 --------
 322  red
 323  yellow
 324  green
 325  blue
 326  purple
 327 (5 rows)
 328
 329 SELECT * FROM enumtest WHERE col > 'yellow' ORDER BY col;
 330   col
 331 --------
 332  green
 333  blue
 334  purple
 335 (3 rows)
 336
 337 SELECT * FROM enumtest WHERE col >= 'yellow' ORDER BY col;
 338   col
 339 --------
 340  yellow
 341  green
 342  blue
 343  purple
 344 (4 rows)
 345
 346 SELECT * FROM enumtest WHERE col < 'green' ORDER BY col;
 347   col
 348 --------
 349  red
 350  orange
 351  yellow
 352 (3 rows)
 353
 354 SELECT * FROM enumtest WHERE col <= 'green' ORDER BY col;
 355   col
 356 --------
 357  red
 358  orange
 359  yellow
 360  green
 361 (4 rows)
 362
 363 SELECT min(col) FROM enumtest;
 364  min
 365 -----
 366  red
 367 (1 row)
 368
 369 SELECT max(col) FROM enumtest;
 370   max
 371 --------
 372  purple
 373 (1 row)
 374
 375 SELECT max(col) FROM enumtest WHERE col < 'green';
 376   max
 377 --------
 378  yellow
 379 (1 row)
 380
 381 DROP INDEX enumtest_btree;
 382 --
 383 -- Hash index / opclass with the = operator
 384 --
 385 CREATE INDEX enumtest_hash ON enumtest USING hash (col);
 386 SELECT * FROM enumtest WHERE col = 'orange';
 387   col
 388 --------
 389  orange
 390 (1 row)
 391
 392 DROP INDEX enumtest_hash;
 393 --
 394 -- End index tests
 395 --
 396 RESET enable_seqscan;
 397 RESET enable_bitmapscan;
 398 --
 399 -- Domains over enums
 400 --
 401 CREATE DOMAIN rgb AS rainbow CHECK (VALUE IN ('red', 'green', 'blue'));
 402 SELECT 'red'::rgb;
 403  rgb
 404 -----
 405  red
 406 (1 row)
 407
 408 SELECT 'purple'::rgb;
 409 ERROR:  value for domain rgb violates check constraint "rgb_check"
 410 SELECT 'purple'::rainbow::rgb;
 411 ERROR:  value for domain rgb violates check constraint "rgb_check"
 412 DROP DOMAIN rgb;
 413 --
 414 -- Arrays
 415 --
 416 SELECT '{red,green,blue}'::rainbow[];
 417      rainbow
 418 ------------------
 419  {red,green,blue}
 420 (1 row)
 421
 422 SELECT ('{red,green,blue}'::rainbow[])[2];
 423  rainbow
 424 ---------
 425  green
 426 (1 row)
 427
 428 SELECT 'red' = ANY ('{red,green,blue}'::rainbow[]);
 429  ?column?
 430 ----------
 431  t
 432 (1 row)
 433
 434 SELECT 'yellow' = ANY ('{red,green,blue}'::rainbow[]);
 435  ?column?
 436 ----------
 437  f
 438 (1 row)
 439
 440 SELECT 'red' = ALL ('{red,green,blue}'::rainbow[]);
 441  ?column?
 442 ----------
 443  f
 444 (1 row)
 445
 446 SELECT 'red' = ALL ('{red,red}'::rainbow[]);
 447  ?column?
 448 ----------
 449  t
 450 (1 row)
 451
 452 --
 453 -- Support functions
 454 --
 455 SELECT enum_first(NULL::rainbow);
 456  enum_first
 457 ------------
 458  red
 459 (1 row)
 460
 461 SELECT enum_last('green'::rainbow);
 462  enum_last
 463 -----------
 464  purple
 465 (1 row)
 466
 467 SELECT enum_range(NULL::rainbow);
 468               enum_range
 469 ---------------------------------------
 470  {red,orange,yellow,green,blue,purple}
 471 (1 row)
 472
 473 SELECT enum_range('orange'::rainbow, 'green'::rainbow);
 474       enum_range
 475 -----------------------
 476  {orange,yellow,green}
 477 (1 row)
 478
 479 SELECT enum_range(NULL, 'green'::rainbow);
 480         enum_range
 481 ---------------------------
 482  {red,orange,yellow,green}
 483 (1 row)
 484
 485 SELECT enum_range('orange'::rainbow, NULL);
 486             enum_range
 487 -----------------------------------
 488  {orange,yellow,green,blue,purple}
 489 (1 row)
 490
 491 SELECT enum_range(NULL::rainbow, NULL);
 492               enum_range
 493 ---------------------------------------
 494  {red,orange,yellow,green,blue,purple}
 495 (1 row)
 496
 497 --
 498 -- User functions, can't test perl/python etc here since may not be compiled.
 499 --
 500 CREATE FUNCTION echo_me(anyenum) RETURNS text AS $$
 501 BEGIN
 502 RETURN $1::text || 'omg';
 503 END
 504 $$ LANGUAGE plpgsql;
 505 SELECT echo_me('red'::rainbow);
 506  echo_me
 507 ---------
 508  redomg
 509 (1 row)
 510
 511 --
 512 -- Concrete function should override generic one
 513 --
 514 CREATE FUNCTION echo_me(rainbow) RETURNS text AS $$
 515 BEGIN
 516 RETURN $1::text || 'wtf';
 517 END
 518 $$ LANGUAGE plpgsql;
 519 SELECT echo_me('red'::rainbow);
 520  echo_me
 521 ---------
 522  redwtf
 523 (1 row)
 524
 525 --
 526 -- If we drop the original generic one, we don't have to qualify the type
 527 -- anymore, since there's only one match
 528 --
 529 DROP FUNCTION echo_me(anyenum);
 530 SELECT echo_me('red');
 531  echo_me
 532 ---------
 533  redwtf
 534 (1 row)
 535
 536 DROP FUNCTION echo_me(rainbow);
 537 --
 538 -- RI triggers on enum types
 539 --
 540 CREATE TABLE enumtest_parent (id rainbow PRIMARY KEY);
 541 CREATE TABLE enumtest_child (parent rainbow REFERENCES enumtest_parent);
 542 INSERT INTO enumtest_parent VALUES ('red');
 543 INSERT INTO enumtest_child VALUES ('red');
 544 INSERT INTO enumtest_child VALUES ('blue');  -- fail
 545 ERROR:  insert or update on table "enumtest_child" violates foreign key constraint "enumtest_child_parent_fkey"
 546 DETAIL:  Key (parent)=(blue) is not present in table "enumtest_parent".
 547 DELETE FROM enumtest_parent;  -- fail
 548 ERROR:  update or delete on table "enumtest_parent" violates foreign key constraint "enumtest_child_parent_fkey" on table "enumtest_child"
 549 DETAIL:  Key (id)=(red) is still referenced from table "enumtest_child".
 550 --
 551 -- cross-type RI should fail
 552 --
 553 CREATE TYPE bogus AS ENUM('good', 'bad', 'ugly');
 554 CREATE TABLE enumtest_bogus_child(parent bogus REFERENCES enumtest_parent);
 555 ERROR:  foreign key constraint "enumtest_bogus_child_parent_fkey" cannot be implemented
 556 DETAIL:  Key columns "parent" and "id" are of incompatible types: bogus and rainbow.
 557 DROP TYPE bogus;
 558 -- check renaming a value
 559 ALTER TYPE rainbow RENAME VALUE 'red' TO 'crimson';
 560 SELECT enumlabel, enumsortorder
 561 FROM pg_enum
 562 WHERE enumtypid = 'rainbow'::regtype
 563 ORDER BY 2;
 564  enumlabel | enumsortorder
 565 -----------+---------------
 566  crimson   |             1
 567  orange    |             2
 568  yellow    |             3
 569  green     |             4
 570  blue      |             5
 571  purple    |             6
 572 (6 rows)
 573
 574 -- check that renaming a non-existent value fails
 575 ALTER TYPE rainbow RENAME VALUE 'red' TO 'crimson';
 576 ERROR:  "red" is not an existing enum label
 577 -- check that renaming to an existent value fails
 578 ALTER TYPE rainbow RENAME VALUE 'blue' TO 'green';
 579 ERROR:  enum label "green" already exists
 580 --
 581 -- check transactional behaviour of ALTER TYPE ... ADD VALUE
 582 --
 583 CREATE TYPE bogus AS ENUM('good');
 584 -- check that we can add new values to existing enums in a transaction
 585 -- but we can't use them
 586 BEGIN;
 587 ALTER TYPE bogus ADD VALUE 'new';
 588 SAVEPOINT x;
 589 SELECT 'new'::bogus;  -- unsafe
 590 ERROR:  unsafe use of new value "new" of enum type bogus
 591 LINE 1: SELECT 'new'::bogus;
 592                ^
 593 HINT:  New enum values must be committed before they can be used.
 594 ROLLBACK TO x;
 595 SELECT enum_first(null::bogus);  -- safe
 596  enum_first
 597 ------------
 598  good
 599 (1 row)
 600
 601 SELECT enum_last(null::bogus);  -- unsafe
 602 ERROR:  unsafe use of new value "new" of enum type bogus
 603 HINT:  New enum values must be committed before they can be used.
 604 ROLLBACK TO x;
 605 SELECT enum_range(null::bogus);  -- unsafe
 606 ERROR:  unsafe use of new value "new" of enum type bogus
 607 HINT:  New enum values must be committed before they can be used.
 608 ROLLBACK TO x;
 609 COMMIT;
 610 SELECT 'new'::bogus;  -- now safe
 611  bogus
 612 -------
 613  new
 614 (1 row)
 615
 616 SELECT enumlabel, enumsortorder
 617 FROM pg_enum
 618 WHERE enumtypid = 'bogus'::regtype
 619 ORDER BY 2;
 620  enumlabel | enumsortorder
 621 -----------+---------------
 622  good      |             1
 623  new       |             2
 624 (2 rows)
 625
 626 -- check that we recognize the case where the enum already existed but was
 627 -- modified in the current txn; this should not be considered safe
 628 BEGIN;
 629 ALTER TYPE bogus RENAME TO bogon;
 630 ALTER TYPE bogon ADD VALUE 'bad';
 631 SELECT 'bad'::bogon;
 632 ERROR:  unsafe use of new value "bad" of enum type bogon
 633 LINE 1: SELECT 'bad'::bogon;
 634                ^
 635 HINT:  New enum values must be committed before they can be used.
 636 ROLLBACK;
 637 -- but a renamed value is safe to use later in same transaction
 638 BEGIN;
 639 ALTER TYPE bogus RENAME VALUE 'good' to 'bad';
 640 SELECT 'bad'::bogus;
 641  bogus
 642 -------
 643  bad
 644 (1 row)
 645
 646 ROLLBACK;
 647 DROP TYPE bogus;
 648 -- check that values created during CREATE TYPE can be used in any case
 649 BEGIN;
 650 CREATE TYPE bogus AS ENUM('good','bad','ugly');
 651 ALTER TYPE bogus RENAME TO bogon;
 652 select enum_range(null::bogon);
 653    enum_range
 654 -----------------
 655  {good,bad,ugly}
 656 (1 row)
 657
 658 ROLLBACK;
 659 -- ideally, we'd allow this usage; but it requires keeping track of whether
 660 -- the enum type was created in the current transaction, which is expensive
 661 BEGIN;
 662 CREATE TYPE bogus AS ENUM('good');
 663 ALTER TYPE bogus RENAME TO bogon;
 664 ALTER TYPE bogon ADD VALUE 'bad';
 665 ALTER TYPE bogon ADD VALUE 'ugly';
 666 select enum_range(null::bogon);  -- fails
 667 ERROR:  unsafe use of new value "bad" of enum type bogon
 668 HINT:  New enum values must be committed before they can be used.
 669 ROLLBACK;
 670 --
 671 -- Cleanup
 672 --
 673 DROP TABLE enumtest_child;
 674 DROP TABLE enumtest_parent;
 675 DROP TABLE enumtest;
 676 DROP TYPE rainbow;
 677 --
 678 -- Verify properly cleaned up
 679 --
 680 SELECT COUNT(*) FROM pg_type WHERE typname = 'rainbow';
 681  count
 682 -------
 683      0
 684 (1 row)
 685
 686 SELECT * FROM pg_enum WHERE NOT EXISTS
 687   (SELECT 1 FROM pg_type WHERE pg_type.oid = enumtypid);
 688  oid | enumtypid | enumsortorder | enumlabel
 689 -----+-----------+---------------+-----------
 690 (0 rows)
 691