src/test/regress/expected/rangetypes.out

   1 -- Tests for range data types.
   2 --
   3 -- test input parser
   4 -- (type textrange was already made in test_setup.sql)
   5 --
   6 -- negative tests; should fail
   7 select ''::textrange;
   8 ERROR:  malformed range literal: ""
   9 LINE 1: select ''::textrange;
  10                ^
  11 DETAIL:  Missing left parenthesis or bracket.
  12 select '-[a,z)'::textrange;
  13 ERROR:  malformed range literal: "-[a,z)"
  14 LINE 1: select '-[a,z)'::textrange;
  15                ^
  16 DETAIL:  Missing left parenthesis or bracket.
  17 select '[a,z) - '::textrange;
  18 ERROR:  malformed range literal: "[a,z) - "
  19 LINE 1: select '[a,z) - '::textrange;
  20                ^
  21 DETAIL:  Junk after right parenthesis or bracket.
  22 select '(",a)'::textrange;
  23 ERROR:  malformed range literal: "(",a)"
  24 LINE 1: select '(",a)'::textrange;
  25                ^
  26 DETAIL:  Unexpected end of input.
  27 select '(,,a)'::textrange;
  28 ERROR:  malformed range literal: "(,,a)"
  29 LINE 1: select '(,,a)'::textrange;
  30                ^
  31 DETAIL:  Too many commas.
  32 select '(),a)'::textrange;
  33 ERROR:  malformed range literal: "(),a)"
  34 LINE 1: select '(),a)'::textrange;
  35                ^
  36 DETAIL:  Missing comma after lower bound.
  37 select '(a,))'::textrange;
  38 ERROR:  malformed range literal: "(a,))"
  39 LINE 1: select '(a,))'::textrange;
  40                ^
  41 DETAIL:  Junk after right parenthesis or bracket.
  42 select '(],a)'::textrange;
  43 ERROR:  malformed range literal: "(],a)"
  44 LINE 1: select '(],a)'::textrange;
  45                ^
  46 DETAIL:  Missing comma after lower bound.
  47 select '(a,])'::textrange;
  48 ERROR:  malformed range literal: "(a,])"
  49 LINE 1: select '(a,])'::textrange;
  50                ^
  51 DETAIL:  Junk after right parenthesis or bracket.
  52 select '[z,a]'::textrange;
  53 ERROR:  range lower bound must be less than or equal to range upper bound
  54 LINE 1: select '[z,a]'::textrange;
  55                ^
  56 -- should succeed
  57 select '  empty  '::textrange;
  58  textrange
  59 -----------
  60  empty
  61 (1 row)
  62
  63 select ' ( empty, empty )  '::textrange;
  64       textrange
  65 ----------------------
  66  (" empty"," empty ")
  67 (1 row)
  68
  69 select ' ( " a " " a ", " z " " z " )  '::textrange;
  70         textrange
  71 --------------------------
  72  ("  a   a ","  z   z  ")
  73 (1 row)
  74
  75 select '(a,)'::textrange;
  76  textrange
  77 -----------
  78  (a,)
  79 (1 row)
  80
  81 select '[,z]'::textrange;
  82  textrange
  83 -----------
  84  (,z]
  85 (1 row)
  86
  87 select '[a,]'::textrange;
  88  textrange
  89 -----------
  90  [a,)
  91 (1 row)
  92
  93 select '(,)'::textrange;
  94  textrange
  95 -----------
  96  (,)
  97 (1 row)
  98
  99 select '[ , ]'::textrange;
 100  textrange
 101 -----------
 102  [" "," "]
 103 (1 row)
 104
 105 select '["",""]'::textrange;
 106  textrange
 107 -----------
 108  ["",""]
 109 (1 row)
 110
 111 select '[",",","]'::textrange;
 112  textrange
 113 -----------
 114  [",",","]
 115 (1 row)
 116
 117 select '["\\","\\"]'::textrange;
 118   textrange
 119 -------------
 120  ["\\","\\"]
 121 (1 row)
 122
 123 select '(\\,a)'::textrange;
 124  textrange
 125 -----------
 126  ("\\",a)
 127 (1 row)
 128
 129 select '((,z)'::textrange;
 130  textrange
 131 -----------
 132  ("(",z)
 133 (1 row)
 134
 135 select '([,z)'::textrange;
 136  textrange
 137 -----------
 138  ("[",z)
 139 (1 row)
 140
 141 select '(!,()'::textrange;
 142  textrange
 143 -----------
 144  (!,"(")
 145 (1 row)
 146
 147 select '(!,[)'::textrange;
 148  textrange
 149 -----------
 150  (!,"[")
 151 (1 row)
 152
 153 select '[a,a]'::textrange;
 154  textrange
 155 -----------
 156  [a,a]
 157 (1 row)
 158
 159 -- these are allowed but normalize to empty:
 160 select '[a,a)'::textrange;
 161  textrange
 162 -----------
 163  empty
 164 (1 row)
 165
 166 select '(a,a]'::textrange;
 167  textrange
 168 -----------
 169  empty
 170 (1 row)
 171
 172 select '(a,a)'::textrange;
 173  textrange
 174 -----------
 175  empty
 176 (1 row)
 177
 178 -- Also try it with non-error-throwing API
 179 select pg_input_is_valid('(1,4)', 'int4range');
 180  pg_input_is_valid
 181 -------------------
 182  t
 183 (1 row)
 184
 185 select pg_input_is_valid('(1,4', 'int4range');
 186  pg_input_is_valid
 187 -------------------
 188  f
 189 (1 row)
 190
 191 select * from pg_input_error_info('(1,4', 'int4range');
 192              message             |          detail          | hint | sql_error_code
 193 ---------------------------------+--------------------------+------+----------------
 194  malformed range literal: "(1,4" | Unexpected end of input. |      | 22P02
 195 (1 row)
 196
 197 select pg_input_is_valid('(4,1)', 'int4range');
 198  pg_input_is_valid
 199 -------------------
 200  f
 201 (1 row)
 202
 203 select * from pg_input_error_info('(4,1)', 'int4range');
 204                               message                              | detail | hint | sql_error_code
 205 -------------------------------------------------------------------+--------+------+----------------
 206  range lower bound must be less than or equal to range upper bound |        |      | 22000
 207 (1 row)
 208
 209 select pg_input_is_valid('(4,zed)', 'int4range');
 210  pg_input_is_valid
 211 -------------------
 212  f
 213 (1 row)
 214
 215 select * from pg_input_error_info('(4,zed)', 'int4range');
 216                    message                    | detail | hint | sql_error_code
 217 ----------------------------------------------+--------+------+----------------
 218  invalid input syntax for type integer: "zed" |        |      | 22P02
 219 (1 row)
 220
 221 select pg_input_is_valid('[1,2147483647]', 'int4range');
 222  pg_input_is_valid
 223 -------------------
 224  f
 225 (1 row)
 226
 227 select * from pg_input_error_info('[1,2147483647]', 'int4range');
 228        message        | detail | hint | sql_error_code
 229 ----------------------+--------+------+----------------
 230  integer out of range |        |      | 22003
 231 (1 row)
 232
 233 select pg_input_is_valid('[2000-01-01,5874897-12-31]', 'daterange');
 234  pg_input_is_valid
 235 -------------------
 236  f
 237 (1 row)
 238
 239 select * from pg_input_error_info('[2000-01-01,5874897-12-31]', 'daterange');
 240       message      | detail | hint | sql_error_code
 241 -------------------+--------+------+----------------
 242  date out of range |        |      | 22008
 243 (1 row)
 244
 245 --
 246 -- create some test data and test the operators
 247 --
 248 CREATE TABLE numrange_test (nr NUMRANGE);
 249 create index numrange_test_btree on numrange_test(nr);
 250 INSERT INTO numrange_test VALUES('[,)');
 251 INSERT INTO numrange_test VALUES('[3,]');
 252 INSERT INTO numrange_test VALUES('[, 5)');
 253 INSERT INTO numrange_test VALUES(numrange(1.1, 2.2));
 254 INSERT INTO numrange_test VALUES('empty');
 255 INSERT INTO numrange_test VALUES(numrange(1.7, 1.7, '[]'));
 256 SELECT nr, isempty(nr), lower(nr), upper(nr) FROM numrange_test;
 257     nr     | isempty | lower | upper
 258 -----------+---------+-------+-------
 259  (,)       | f       |       |
 260  [3,)      | f       |     3 |
 261  (,5)      | f       |       |     5
 262  [1.1,2.2) | f       |   1.1 |   2.2
 263  empty     | t       |       |
 264  [1.7,1.7] | f       |   1.7 |   1.7
 265 (6 rows)
 266
 267 SELECT nr, lower_inc(nr), lower_inf(nr), upper_inc(nr), upper_inf(nr) FROM numrange_test;
 268     nr     | lower_inc | lower_inf | upper_inc | upper_inf
 269 -----------+-----------+-----------+-----------+-----------
 270  (,)       | f         | t         | f         | t
 271  [3,)      | t         | f         | f         | t
 272  (,5)      | f         | t         | f         | f
 273  [1.1,2.2) | t         | f         | f         | f
 274  empty     | f         | f         | f         | f
 275  [1.7,1.7] | t         | f         | t         | f
 276 (6 rows)
 277
 278 SELECT * FROM numrange_test WHERE range_contains(nr, numrange(1.9,1.91));
 279     nr
 280 -----------
 281  (,)
 282  (,5)
 283  [1.1,2.2)
 284 (3 rows)
 285
 286 SELECT * FROM numrange_test WHERE nr @> numrange(1.0,10000.1);
 287  nr
 288 -----
 289  (,)
 290 (1 row)
 291
 292 SELECT * FROM numrange_test WHERE range_contained_by(numrange(-1e7,-10000.1), nr);
 293   nr
 294 ------
 295  (,)
 296  (,5)
 297 (2 rows)
 298
 299 SELECT * FROM numrange_test WHERE 1.9 <@ nr;
 300     nr
 301 -----------
 302  (,)
 303  (,5)
 304  [1.1,2.2)
 305 (3 rows)
 306
 307 select * from numrange_test where nr = 'empty';
 308   nr
 309 -------
 310  empty
 311 (1 row)
 312
 313 select * from numrange_test where nr = '(1.1, 2.2)';
 314  nr
 315 ----
 316 (0 rows)
 317
 318 select * from numrange_test where nr = '[1.1, 2.2)';
 319     nr
 320 -----------
 321  [1.1,2.2)
 322 (1 row)
 323
 324 select * from numrange_test where nr < 'empty';
 325  nr
 326 ----
 327 (0 rows)
 328
 329 select * from numrange_test where nr < numrange(-1000.0, -1000.0,'[]');
 330   nr
 331 -------
 332  (,)
 333  (,5)
 334  empty
 335 (3 rows)
 336
 337 select * from numrange_test where nr < numrange(0.0, 1.0,'[]');
 338   nr
 339 -------
 340  (,)
 341  (,5)
 342  empty
 343 (3 rows)
 344
 345 select * from numrange_test where nr < numrange(1000.0, 1001.0,'[]');
 346     nr
 347 -----------
 348  (,)
 349  [3,)
 350  (,5)
 351  [1.1,2.2)
 352  empty
 353  [1.7,1.7]
 354 (6 rows)
 355
 356 select * from numrange_test where nr <= 'empty';
 357   nr
 358 -------
 359  empty
 360 (1 row)
 361
 362 select * from numrange_test where nr >= 'empty';
 363     nr
 364 -----------
 365  (,)
 366  [3,)
 367  (,5)
 368  [1.1,2.2)
 369  empty
 370  [1.7,1.7]
 371 (6 rows)
 372
 373 select * from numrange_test where nr > 'empty';
 374     nr
 375 -----------
 376  (,)
 377  [3,)
 378  (,5)
 379  [1.1,2.2)
 380  [1.7,1.7]
 381 (5 rows)
 382
 383 select * from numrange_test where nr > numrange(-1001.0, -1000.0,'[]');
 384     nr
 385 -----------
 386  [3,)
 387  [1.1,2.2)
 388  [1.7,1.7]
 389 (3 rows)
 390
 391 select * from numrange_test where nr > numrange(0.0, 1.0,'[]');
 392     nr
 393 -----------
 394  [3,)
 395  [1.1,2.2)
 396  [1.7,1.7]
 397 (3 rows)
 398
 399 select * from numrange_test where nr > numrange(1000.0, 1000.0,'[]');
 400  nr
 401 ----
 402 (0 rows)
 403
 404 select numrange(2.0, 1.0);
 405 ERROR:  range lower bound must be less than or equal to range upper bound
 406 select numrange(2.0, 3.0) -|- numrange(3.0, 4.0);
 407  ?column?
 408 ----------
 409  t
 410 (1 row)
 411
 412 select range_adjacent(numrange(2.0, 3.0), numrange(3.1, 4.0));
 413  range_adjacent
 414 ----------------
 415  f
 416 (1 row)
 417
 418 select range_adjacent(numrange(2.0, 3.0), numrange(3.1, null));
 419  range_adjacent
 420 ----------------
 421  f
 422 (1 row)
 423
 424 select numrange(2.0, 3.0, '[]') -|- numrange(3.0, 4.0, '()');
 425  ?column?
 426 ----------
 427  t
 428 (1 row)
 429
 430 select numrange(1.0, 2.0) -|- numrange(2.0, 3.0,'[]');
 431  ?column?
 432 ----------
 433  t
 434 (1 row)
 435
 436 select range_adjacent(numrange(2.0, 3.0, '(]'), numrange(1.0, 2.0, '(]'));
 437  range_adjacent
 438 ----------------
 439  t
 440 (1 row)
 441
 442 select numrange(1.1, 3.3) <@ numrange(0.1,10.1);
 443  ?column?
 444 ----------
 445  t
 446 (1 row)
 447
 448 select numrange(0.1, 10.1) <@ numrange(1.1,3.3);
 449  ?column?
 450 ----------
 451  f
 452 (1 row)
 453
 454 select numrange(1.1, 2.2) - numrange(2.0, 3.0);
 455  ?column?
 456 -----------
 457  [1.1,2.0)
 458 (1 row)
 459
 460 select numrange(1.1, 2.2) - numrange(2.2, 3.0);
 461  ?column?
 462 -----------
 463  [1.1,2.2)
 464 (1 row)
 465
 466 select numrange(1.1, 2.2,'[]') - numrange(2.0, 3.0);
 467  ?column?
 468 -----------
 469  [1.1,2.0)
 470 (1 row)
 471
 472 select range_minus(numrange(10.1,12.2,'[]'), numrange(110.0,120.2,'(]'));
 473  range_minus
 474 -------------
 475  [10.1,12.2]
 476 (1 row)
 477
 478 select range_minus(numrange(10.1,12.2,'[]'), numrange(0.0,120.2,'(]'));
 479  range_minus
 480 -------------
 481  empty
 482 (1 row)
 483
 484 select numrange(4.5, 5.5, '[]') && numrange(5.5, 6.5);
 485  ?column?
 486 ----------
 487  t
 488 (1 row)
 489
 490 select numrange(1.0, 2.0) << numrange(3.0, 4.0);
 491  ?column?
 492 ----------
 493  t
 494 (1 row)
 495
 496 select numrange(1.0, 3.0,'[]') << numrange(3.0, 4.0,'[]');
 497  ?column?
 498 ----------
 499  f
 500 (1 row)
 501
 502 select numrange(1.0, 3.0,'()') << numrange(3.0, 4.0,'()');
 503  ?column?
 504 ----------
 505  t
 506 (1 row)
 507
 508 select numrange(1.0, 2.0) >> numrange(3.0, 4.0);
 509  ?column?
 510 ----------
 511  f
 512 (1 row)
 513
 514 select numrange(3.0, 70.0) &< numrange(6.6, 100.0);
 515  ?column?
 516 ----------
 517  t
 518 (1 row)
 519
 520 select numrange(1.1, 2.2) < numrange(1.0, 200.2);
 521  ?column?
 522 ----------
 523  f
 524 (1 row)
 525
 526 select numrange(1.1, 2.2) < numrange(1.1, 1.2);
 527  ?column?
 528 ----------
 529  f
 530 (1 row)
 531
 532 select numrange(1.0, 2.0) + numrange(2.0, 3.0);
 533  ?column?
 534 -----------
 535  [1.0,3.0)
 536 (1 row)
 537
 538 select numrange(1.0, 2.0) + numrange(1.5, 3.0);
 539  ?column?
 540 -----------
 541  [1.0,3.0)
 542 (1 row)
 543
 544 select numrange(1.0, 2.0) + numrange(2.5, 3.0); -- should fail
 545 ERROR:  result of range union would not be contiguous
 546 select range_merge(numrange(1.0, 2.0), numrange(2.0, 3.0));
 547  range_merge
 548 -------------
 549  [1.0,3.0)
 550 (1 row)
 551
 552 select range_merge(numrange(1.0, 2.0), numrange(1.5, 3.0));
 553  range_merge
 554 -------------
 555  [1.0,3.0)
 556 (1 row)
 557
 558 select range_merge(numrange(1.0, 2.0), numrange(2.5, 3.0)); -- shouldn't fail
 559  range_merge
 560 -------------
 561  [1.0,3.0)
 562 (1 row)
 563
 564 select numrange(1.0, 2.0) * numrange(2.0, 3.0);
 565  ?column?
 566 ----------
 567  empty
 568 (1 row)
 569
 570 select numrange(1.0, 2.0) * numrange(1.5, 3.0);
 571  ?column?
 572 -----------
 573  [1.5,2.0)
 574 (1 row)
 575
 576 select numrange(1.0, 2.0) * numrange(2.5, 3.0);
 577  ?column?
 578 ----------
 579  empty
 580 (1 row)
 581
 582 select range_intersect_agg(nr) from numrange_test;
 583  range_intersect_agg
 584 ---------------------
 585  empty
 586 (1 row)
 587
 588 select range_intersect_agg(nr) from numrange_test where false;
 589  range_intersect_agg
 590 ---------------------
 591
 592 (1 row)
 593
 594 select range_intersect_agg(nr) from numrange_test where nr @> 4.0;
 595  range_intersect_agg
 596 ---------------------
 597  [3,5)
 598 (1 row)
 599
 600 analyze numrange_test;
 601 create table numrange_test2(nr numrange);
 602 create index numrange_test2_hash_idx on numrange_test2 using hash (nr);
 603 INSERT INTO numrange_test2 VALUES('[, 5)');
 604 INSERT INTO numrange_test2 VALUES(numrange(1.1, 2.2));
 605 INSERT INTO numrange_test2 VALUES(numrange(1.1, 2.2));
 606 INSERT INTO numrange_test2 VALUES(numrange(1.1, 2.2,'()'));
 607 INSERT INTO numrange_test2 VALUES('empty');
 608 select * from numrange_test2 where nr = 'empty'::numrange;
 609   nr
 610 -------
 611  empty
 612 (1 row)
 613
 614 select * from numrange_test2 where nr = numrange(1.1, 2.2);
 615     nr
 616 -----------
 617  [1.1,2.2)
 618  [1.1,2.2)
 619 (2 rows)
 620
 621 select * from numrange_test2 where nr = numrange(1.1, 2.3);
 622  nr
 623 ----
 624 (0 rows)
 625
 626 set enable_nestloop=t;
 627 set enable_hashjoin=f;
 628 set enable_mergejoin=f;
 629 select * from numrange_test natural join numrange_test2 order by nr;
 630     nr
 631 -----------
 632  empty
 633  (,5)
 634  [1.1,2.2)
 635  [1.1,2.2)
 636 (4 rows)
 637
 638 set enable_nestloop=f;
 639 set enable_hashjoin=t;
 640 set enable_mergejoin=f;
 641 select * from numrange_test natural join numrange_test2 order by nr;
 642     nr
 643 -----------
 644  empty
 645  (,5)
 646  [1.1,2.2)
 647  [1.1,2.2)
 648 (4 rows)
 649
 650 set enable_nestloop=f;
 651 set enable_hashjoin=f;
 652 set enable_mergejoin=t;
 653 select * from numrange_test natural join numrange_test2 order by nr;
 654     nr
 655 -----------
 656  empty
 657  (,5)
 658  [1.1,2.2)
 659  [1.1,2.2)
 660 (4 rows)
 661
 662 set enable_nestloop to default;
 663 set enable_hashjoin to default;
 664 set enable_mergejoin to default;
 665 -- keep numrange_test around to help exercise dump/reload
 666 DROP TABLE numrange_test2;
 667 --
 668 -- Apply a subset of the above tests on a collatable type, too
 669 --
 670 CREATE TABLE textrange_test (tr textrange);
 671 create index textrange_test_btree on textrange_test(tr);
 672 INSERT INTO textrange_test VALUES('[,)');
 673 INSERT INTO textrange_test VALUES('["a",]');
 674 INSERT INTO textrange_test VALUES('[,"q")');
 675 INSERT INTO textrange_test VALUES(textrange('b', 'g'));
 676 INSERT INTO textrange_test VALUES('empty');
 677 INSERT INTO textrange_test VALUES(textrange('d', 'd', '[]'));
 678 SELECT tr, isempty(tr), lower(tr), upper(tr) FROM textrange_test;
 679   tr   | isempty | lower | upper
 680 -------+---------+-------+-------
 681  (,)   | f       |       |
 682  [a,)  | f       | a     |
 683  (,q)  | f       |       | q
 684  [b,g) | f       | b     | g
 685  empty | t       |       |
 686  [d,d] | f       | d     | d
 687 (6 rows)
 688
 689 SELECT tr, lower_inc(tr), lower_inf(tr), upper_inc(tr), upper_inf(tr) FROM textrange_test;
 690   tr   | lower_inc | lower_inf | upper_inc | upper_inf
 691 -------+-----------+-----------+-----------+-----------
 692  (,)   | f         | t         | f         | t
 693  [a,)  | t         | f         | f         | t
 694  (,q)  | f         | t         | f         | f
 695  [b,g) | t         | f         | f         | f
 696  empty | f         | f         | f         | f
 697  [d,d] | t         | f         | t         | f
 698 (6 rows)
 699
 700 SELECT * FROM textrange_test WHERE range_contains(tr, textrange('f', 'fx'));
 701   tr
 702 -------
 703  (,)
 704  [a,)
 705  (,q)
 706  [b,g)
 707 (4 rows)
 708
 709 SELECT * FROM textrange_test WHERE tr @> textrange('a', 'z');
 710   tr
 711 ------
 712  (,)
 713  [a,)
 714 (2 rows)
 715
 716 SELECT * FROM textrange_test WHERE range_contained_by(textrange('0','9'), tr);
 717   tr
 718 ------
 719  (,)
 720  (,q)
 721 (2 rows)
 722
 723 SELECT * FROM textrange_test WHERE 'e'::text <@ tr;
 724   tr
 725 -------
 726  (,)
 727  [a,)
 728  (,q)
 729  [b,g)
 730 (4 rows)
 731
 732 select * from textrange_test where tr = 'empty';
 733   tr
 734 -------
 735  empty
 736 (1 row)
 737
 738 select * from textrange_test where tr = '("b","g")';
 739  tr
 740 ----
 741 (0 rows)
 742
 743 select * from textrange_test where tr = '["b","g")';
 744   tr
 745 -------
 746  [b,g)
 747 (1 row)
 748
 749 select * from textrange_test where tr < 'empty';
 750  tr
 751 ----
 752 (0 rows)
 753
 754 -- test canonical form for int4range
 755 select int4range(1, 10, '[]');
 756  int4range
 757 -----------
 758  [1,11)
 759 (1 row)
 760
 761 select int4range(1, 10, '[)');
 762  int4range
 763 -----------
 764  [1,10)
 765 (1 row)
 766
 767 select int4range(1, 10, '(]');
 768  int4range
 769 -----------
 770  [2,11)
 771 (1 row)
 772
 773 select int4range(1, 10, '()');
 774  int4range
 775 -----------
 776  [2,10)
 777 (1 row)
 778
 779 select int4range(1, 2, '()');
 780  int4range
 781 -----------
 782  empty
 783 (1 row)
 784
 785 -- test canonical form for daterange
 786 select daterange('2000-01-10'::date, '2000-01-20'::date, '[]');
 787         daterange
 788 -------------------------
 789  [01-10-2000,01-21-2000)
 790 (1 row)
 791
 792 select daterange('2000-01-10'::date, '2000-01-20'::date, '[)');
 793         daterange
 794 -------------------------
 795  [01-10-2000,01-20-2000)
 796 (1 row)
 797
 798 select daterange('2000-01-10'::date, '2000-01-20'::date, '(]');
 799         daterange
 800 -------------------------
 801  [01-11-2000,01-21-2000)
 802 (1 row)
 803
 804 select daterange('2000-01-10'::date, '2000-01-20'::date, '()');
 805         daterange
 806 -------------------------
 807  [01-11-2000,01-20-2000)
 808 (1 row)
 809
 810 select daterange('2000-01-10'::date, '2000-01-11'::date, '()');
 811  daterange
 812 -----------
 813  empty
 814 (1 row)
 815
 816 select daterange('2000-01-10'::date, '2000-01-11'::date, '(]');
 817         daterange
 818 -------------------------
 819  [01-11-2000,01-12-2000)
 820 (1 row)
 821
 822 select daterange('-infinity'::date, '2000-01-01'::date, '()');
 823        daterange
 824 ------------------------
 825  (-infinity,01-01-2000)
 826 (1 row)
 827
 828 select daterange('-infinity'::date, '2000-01-01'::date, '[)');
 829        daterange
 830 ------------------------
 831  [-infinity,01-01-2000)
 832 (1 row)
 833
 834 select daterange('2000-01-01'::date, 'infinity'::date, '[)');
 835        daterange
 836 -----------------------
 837  [01-01-2000,infinity)
 838 (1 row)
 839
 840 select daterange('2000-01-01'::date, 'infinity'::date, '[]');
 841        daterange
 842 -----------------------
 843  [01-01-2000,infinity]
 844 (1 row)
 845
 846 -- test GiST index that's been built incrementally
 847 create table test_range_gist(ir int4range);
 848 create index test_range_gist_idx on test_range_gist using gist (ir);
 849 insert into test_range_gist select int4range(g, g+10) from generate_series(1,2000) g;
 850 insert into test_range_gist select 'empty'::int4range from generate_series(1,500) g;
 851 insert into test_range_gist select int4range(g, g+10000) from generate_series(1,1000) g;
 852 insert into test_range_gist select 'empty'::int4range from generate_series(1,500) g;
 853 insert into test_range_gist select int4range(NULL,g*10,'(]') from generate_series(1,100) g;
 854 insert into test_range_gist select int4range(g*10,NULL,'(]') from generate_series(1,100) g;
 855 insert into test_range_gist select int4range(g, g+10) from generate_series(1,2000) g;
 856 -- test statistics and selectivity estimation as well
 857 --
 858 -- We don't check the accuracy of selectivity estimation, but at least check
 859 -- it doesn't fall.
 860 analyze test_range_gist;
 861 -- first, verify non-indexed results
 862 SET enable_seqscan    = t;
 863 SET enable_indexscan  = f;
 864 SET enable_bitmapscan = f;
 865 select count(*) from test_range_gist where ir @> 'empty'::int4range;
 866  count
 867 -------
 868   6200
 869 (1 row)
 870
 871 select count(*) from test_range_gist where ir = int4range(10,20);
 872  count
 873 -------
 874      2
 875 (1 row)
 876
 877 select count(*) from test_range_gist where ir @> 10;
 878  count
 879 -------
 880    130
 881 (1 row)
 882
 883 select count(*) from test_range_gist where ir @> int4range(10,20);
 884  count
 885 -------
 886    111
 887 (1 row)
 888
 889 select count(*) from test_range_gist where ir && int4range(10,20);
 890  count
 891 -------
 892    158
 893 (1 row)
 894
 895 select count(*) from test_range_gist where ir <@ int4range(10,50);
 896  count
 897 -------
 898   1062
 899 (1 row)
 900
 901 select count(*) from test_range_gist where ir << int4range(100,500);
 902  count
 903 -------
 904    189
 905 (1 row)
 906
 907 select count(*) from test_range_gist where ir >> int4range(100,500);
 908  count
 909 -------
 910   3554
 911 (1 row)
 912
 913 select count(*) from test_range_gist where ir &< int4range(100,500);
 914  count
 915 -------
 916   1029
 917 (1 row)
 918
 919 select count(*) from test_range_gist where ir &> int4range(100,500);
 920  count
 921 -------
 922   4794
 923 (1 row)
 924
 925 select count(*) from test_range_gist where ir -|- int4range(100,500);
 926  count
 927 -------
 928      5
 929 (1 row)
 930
 931 select count(*) from test_range_gist where ir @> '{}'::int4multirange;
 932  count
 933 -------
 934   6200
 935 (1 row)
 936
 937 select count(*) from test_range_gist where ir @> int4multirange(int4range(10,20), int4range(30,40));
 938  count
 939 -------
 940    107
 941 (1 row)
 942
 943 select count(*) from test_range_gist where ir && '{(10,20),(30,40),(50,60)}'::int4multirange;
 944  count
 945 -------
 946    271
 947 (1 row)
 948
 949 select count(*) from test_range_gist where ir <@ '{(10,30),(40,60),(70,90)}'::int4multirange;
 950  count
 951 -------
 952   1060
 953 (1 row)
 954
 955 select count(*) from test_range_gist where ir << int4multirange(int4range(100,200), int4range(400,500));
 956  count
 957 -------
 958    189
 959 (1 row)
 960
 961 select count(*) from test_range_gist where ir >> int4multirange(int4range(100,200), int4range(400,500));
 962  count
 963 -------
 964   3554
 965 (1 row)
 966
 967 select count(*) from test_range_gist where ir &< int4multirange(int4range(100,200), int4range(400,500));
 968  count
 969 -------
 970   1029
 971 (1 row)
 972
 973 select count(*) from test_range_gist where ir &> int4multirange(int4range(100,200), int4range(400,500));
 974  count
 975 -------
 976   4794
 977 (1 row)
 978
 979 select count(*) from test_range_gist where ir -|- int4multirange(int4range(100,200), int4range(400,500));
 980  count
 981 -------
 982      5
 983 (1 row)
 984
 985 -- now check same queries using index
 986 SET enable_seqscan    = f;
 987 SET enable_indexscan  = t;
 988 SET enable_bitmapscan = f;
 989 select count(*) from test_range_gist where ir @> 'empty'::int4range;
 990  count
 991 -------
 992   6200
 993 (1 row)
 994
 995 select count(*) from test_range_gist where ir = int4range(10,20);
 996  count
 997 -------
 998      2
 999 (1 row)
1000
1001 select count(*) from test_range_gist where ir @> 10;
1002  count
1003 -------
1004    130
1005 (1 row)
1006
1007 select count(*) from test_range_gist where ir @> int4range(10,20);
1008  count
1009 -------
1010    111
1011 (1 row)
1012
1013 select count(*) from test_range_gist where ir && int4range(10,20);
1014  count
1015 -------
1016    158
1017 (1 row)
1018
1019 select count(*) from test_range_gist where ir <@ int4range(10,50);
1020  count
1021 -------
1022   1062
1023 (1 row)
1024
1025 select count(*) from test_range_gist where ir << int4range(100,500);
1026  count
1027 -------
1028    189
1029 (1 row)
1030
1031 select count(*) from test_range_gist where ir >> int4range(100,500);
1032  count
1033 -------
1034   3554
1035 (1 row)
1036
1037 select count(*) from test_range_gist where ir &< int4range(100,500);
1038  count
1039 -------
1040   1029
1041 (1 row)
1042
1043 select count(*) from test_range_gist where ir &> int4range(100,500);
1044  count
1045 -------
1046   4794
1047 (1 row)
1048
1049 select count(*) from test_range_gist where ir -|- int4range(100,500);
1050  count
1051 -------
1052      5
1053 (1 row)
1054
1055 select count(*) from test_range_gist where ir @> '{}'::int4multirange;
1056  count
1057 -------
1058   6200
1059 (1 row)
1060
1061 select count(*) from test_range_gist where ir @> int4multirange(int4range(10,20), int4range(30,40));
1062  count
1063 -------
1064    107
1065 (1 row)
1066
1067 select count(*) from test_range_gist where ir && '{(10,20),(30,40),(50,60)}'::int4multirange;
1068  count
1069 -------
1070    271
1071 (1 row)
1072
1073 select count(*) from test_range_gist where ir <@ '{(10,30),(40,60),(70,90)}'::int4multirange;
1074  count
1075 -------
1076   1060
1077 (1 row)
1078
1079 select count(*) from test_range_gist where ir << int4multirange(int4range(100,200), int4range(400,500));
1080  count
1081 -------
1082    189
1083 (1 row)
1084
1085 select count(*) from test_range_gist where ir >> int4multirange(int4range(100,200), int4range(400,500));
1086  count
1087 -------
1088   3554
1089 (1 row)
1090
1091 select count(*) from test_range_gist where ir &< int4multirange(int4range(100,200), int4range(400,500));
1092  count
1093 -------
1094   1029
1095 (1 row)
1096
1097 select count(*) from test_range_gist where ir &> int4multirange(int4range(100,200), int4range(400,500));
1098  count
1099 -------
1100   4794
1101 (1 row)
1102
1103 select count(*) from test_range_gist where ir -|- int4multirange(int4range(100,200), int4range(400,500));
1104  count
1105 -------
1106      5
1107 (1 row)
1108
1109 -- now check same queries using a bulk-loaded index
1110 drop index test_range_gist_idx;
1111 create index test_range_gist_idx on test_range_gist using gist (ir);
1112 select count(*) from test_range_gist where ir @> 'empty'::int4range;
1113  count
1114 -------
1115   6200
1116 (1 row)
1117
1118 select count(*) from test_range_gist where ir = int4range(10,20);
1119  count
1120 -------
1121      2
1122 (1 row)
1123
1124 select count(*) from test_range_gist where ir @> 10;
1125  count
1126 -------
1127    130
1128 (1 row)
1129
1130 select count(*) from test_range_gist where ir @> int4range(10,20);
1131  count
1132 -------
1133    111
1134 (1 row)
1135
1136 select count(*) from test_range_gist where ir && int4range(10,20);
1137  count
1138 -------
1139    158
1140 (1 row)
1141
1142 select count(*) from test_range_gist where ir <@ int4range(10,50);
1143  count
1144 -------
1145   1062
1146 (1 row)
1147
1148 select count(*) from test_range_gist where ir << int4range(100,500);
1149  count
1150 -------
1151    189
1152 (1 row)
1153
1154 select count(*) from test_range_gist where ir >> int4range(100,500);
1155  count
1156 -------
1157   3554
1158 (1 row)
1159
1160 select count(*) from test_range_gist where ir &< int4range(100,500);
1161  count
1162 -------
1163   1029
1164 (1 row)
1165
1166 select count(*) from test_range_gist where ir &> int4range(100,500);
1167  count
1168 -------
1169   4794
1170 (1 row)
1171
1172 select count(*) from test_range_gist where ir -|- int4range(100,500);
1173  count
1174 -------
1175      5
1176 (1 row)
1177
1178 select count(*) from test_range_gist where ir @> '{}'::int4multirange;
1179  count
1180 -------
1181   6200
1182 (1 row)
1183
1184 select count(*) from test_range_gist where ir @> int4multirange(int4range(10,20), int4range(30,40));
1185  count
1186 -------
1187    107
1188 (1 row)
1189
1190 select count(*) from test_range_gist where ir && '{(10,20),(30,40),(50,60)}'::int4multirange;
1191  count
1192 -------
1193    271
1194 (1 row)
1195
1196 select count(*) from test_range_gist where ir <@ '{(10,30),(40,60),(70,90)}'::int4multirange;
1197  count
1198 -------
1199   1060
1200 (1 row)
1201
1202 select count(*) from test_range_gist where ir << int4multirange(int4range(100,200), int4range(400,500));
1203  count
1204 -------
1205    189
1206 (1 row)
1207
1208 select count(*) from test_range_gist where ir >> int4multirange(int4range(100,200), int4range(400,500));
1209  count
1210 -------
1211   3554
1212 (1 row)
1213
1214 select count(*) from test_range_gist where ir &< int4multirange(int4range(100,200), int4range(400,500));
1215  count
1216 -------
1217   1029
1218 (1 row)
1219
1220 select count(*) from test_range_gist where ir &> int4multirange(int4range(100,200), int4range(400,500));
1221  count
1222 -------
1223   4794
1224 (1 row)
1225
1226 select count(*) from test_range_gist where ir -|- int4multirange(int4range(100,200), int4range(400,500));
1227  count
1228 -------
1229      5
1230 (1 row)
1231
1232 -- test SP-GiST index that's been built incrementally
1233 create table test_range_spgist(ir int4range);
1234 create index test_range_spgist_idx on test_range_spgist using spgist (ir);
1235 insert into test_range_spgist select int4range(g, g+10) from generate_series(1,2000) g;
1236 insert into test_range_spgist select 'empty'::int4range from generate_series(1,500) g;
1237 insert into test_range_spgist select int4range(g, g+10000) from generate_series(1,1000) g;
1238 insert into test_range_spgist select 'empty'::int4range from generate_series(1,500) g;
1239 insert into test_range_spgist select int4range(NULL,g*10,'(]') from generate_series(1,100) g;
1240 insert into test_range_spgist select int4range(g*10,NULL,'(]') from generate_series(1,100) g;
1241 insert into test_range_spgist select int4range(g, g+10) from generate_series(1,2000) g;
1242 -- first, verify non-indexed results
1243 SET enable_seqscan    = t;
1244 SET enable_indexscan  = f;
1245 SET enable_bitmapscan = f;
1246 select count(*) from test_range_spgist where ir @> 'empty'::int4range;
1247  count
1248 -------
1249   6200
1250 (1 row)
1251
1252 select count(*) from test_range_spgist where ir = int4range(10,20);
1253  count
1254 -------
1255      2
1256 (1 row)
1257
1258 select count(*) from test_range_spgist where ir @> 10;
1259  count
1260 -------
1261    130
1262 (1 row)
1263
1264 select count(*) from test_range_spgist where ir @> int4range(10,20);
1265  count
1266 -------
1267    111
1268 (1 row)
1269
1270 select count(*) from test_range_spgist where ir && int4range(10,20);
1271  count
1272 -------
1273    158
1274 (1 row)
1275
1276 select count(*) from test_range_spgist where ir <@ int4range(10,50);
1277  count
1278 -------
1279   1062
1280 (1 row)
1281
1282 select count(*) from test_range_spgist where ir << int4range(100,500);
1283  count
1284 -------
1285    189
1286 (1 row)
1287
1288 select count(*) from test_range_spgist where ir >> int4range(100,500);
1289  count
1290 -------
1291   3554
1292 (1 row)
1293
1294 select count(*) from test_range_spgist where ir &< int4range(100,500);
1295  count
1296 -------
1297   1029
1298 (1 row)
1299
1300 select count(*) from test_range_spgist where ir &> int4range(100,500);
1301  count
1302 -------
1303   4794
1304 (1 row)
1305
1306 select count(*) from test_range_spgist where ir -|- int4range(100,500);
1307  count
1308 -------
1309      5
1310 (1 row)
1311
1312 -- now check same queries using index
1313 SET enable_seqscan    = f;
1314 SET enable_indexscan  = t;
1315 SET enable_bitmapscan = f;
1316 select count(*) from test_range_spgist where ir @> 'empty'::int4range;
1317  count
1318 -------
1319   6200
1320 (1 row)
1321
1322 select count(*) from test_range_spgist where ir = int4range(10,20);
1323  count
1324 -------
1325      2
1326 (1 row)
1327
1328 select count(*) from test_range_spgist where ir @> 10;
1329  count
1330 -------
1331    130
1332 (1 row)
1333
1334 select count(*) from test_range_spgist where ir @> int4range(10,20);
1335  count
1336 -------
1337    111
1338 (1 row)
1339
1340 select count(*) from test_range_spgist where ir && int4range(10,20);
1341  count
1342 -------
1343    158
1344 (1 row)
1345
1346 select count(*) from test_range_spgist where ir <@ int4range(10,50);
1347  count
1348 -------
1349   1062
1350 (1 row)
1351
1352 select count(*) from test_range_spgist where ir << int4range(100,500);
1353  count
1354 -------
1355    189
1356 (1 row)
1357
1358 select count(*) from test_range_spgist where ir >> int4range(100,500);
1359  count
1360 -------
1361   3554
1362 (1 row)
1363
1364 select count(*) from test_range_spgist where ir &< int4range(100,500);
1365  count
1366 -------
1367   1029
1368 (1 row)
1369
1370 select count(*) from test_range_spgist where ir &> int4range(100,500);
1371  count
1372 -------
1373   4794
1374 (1 row)
1375
1376 select count(*) from test_range_spgist where ir -|- int4range(100,500);
1377  count
1378 -------
1379      5
1380 (1 row)
1381
1382 -- now check same queries using a bulk-loaded index
1383 drop index test_range_spgist_idx;
1384 create index test_range_spgist_idx on test_range_spgist using spgist (ir);
1385 select count(*) from test_range_spgist where ir @> 'empty'::int4range;
1386  count
1387 -------
1388   6200
1389 (1 row)
1390
1391 select count(*) from test_range_spgist where ir = int4range(10,20);
1392  count
1393 -------
1394      2
1395 (1 row)
1396
1397 select count(*) from test_range_spgist where ir @> 10;
1398  count
1399 -------
1400    130
1401 (1 row)
1402
1403 select count(*) from test_range_spgist where ir @> int4range(10,20);
1404  count
1405 -------
1406    111
1407 (1 row)
1408
1409 select count(*) from test_range_spgist where ir && int4range(10,20);
1410  count
1411 -------
1412    158
1413 (1 row)
1414
1415 select count(*) from test_range_spgist where ir <@ int4range(10,50);
1416  count
1417 -------
1418   1062
1419 (1 row)
1420
1421 select count(*) from test_range_spgist where ir << int4range(100,500);
1422  count
1423 -------
1424    189
1425 (1 row)
1426
1427 select count(*) from test_range_spgist where ir >> int4range(100,500);
1428  count
1429 -------
1430   3554
1431 (1 row)
1432
1433 select count(*) from test_range_spgist where ir &< int4range(100,500);
1434  count
1435 -------
1436   1029
1437 (1 row)
1438
1439 select count(*) from test_range_spgist where ir &> int4range(100,500);
1440  count
1441 -------
1442   4794
1443 (1 row)
1444
1445 select count(*) from test_range_spgist where ir -|- int4range(100,500);
1446  count
1447 -------
1448      5
1449 (1 row)
1450
1451 -- test index-only scans
1452 explain (costs off)
1453 select ir from test_range_spgist where ir -|- int4range(10,20) order by ir;
1454                                QUERY PLAN
1455 ------------------------------------------------------------------------
1456  Sort
1457    Sort Key: ir
1458    ->  Index Only Scan using test_range_spgist_idx on test_range_spgist
1459          Index Cond: (ir -|- '[10,20)'::int4range)
1460 (4 rows)
1461
1462 select ir from test_range_spgist where ir -|- int4range(10,20) order by ir;
1463      ir
1464 ------------
1465  [20,30)
1466  [20,30)
1467  [20,10020)
1468 (3 rows)
1469
1470 RESET enable_seqscan;
1471 RESET enable_indexscan;
1472 RESET enable_bitmapscan;
1473 -- test elem <@ range operator
1474 create table test_range_elem(i int4);
1475 create index test_range_elem_idx on test_range_elem (i);
1476 insert into test_range_elem select i from generate_series(1,100) i;
1477 SET enable_seqscan    = f;
1478 select count(*) from test_range_elem where i <@ int4range(10,50);
1479  count
1480 -------
1481     40
1482 (1 row)
1483
1484 -- also test spgist index on anyrange expression
1485 create index on test_range_elem using spgist(int4range(i,i+10));
1486 explain (costs off)
1487 select count(*) from test_range_elem where int4range(i,i+10) <@ int4range(10,30);
1488                                QUERY PLAN
1489 -------------------------------------------------------------------------
1490  Aggregate
1491    ->  Index Scan using test_range_elem_int4range_idx on test_range_elem
1492          Index Cond: (int4range(i, (i + 10)) <@ '[10,30)'::int4range)
1493 (3 rows)
1494
1495 select count(*) from test_range_elem where int4range(i,i+10) <@ int4range(10,30);
1496  count
1497 -------
1498     11
1499 (1 row)
1500
1501 RESET enable_seqscan;
1502 drop table test_range_elem;
1503 --
1504 -- Btree_gist is not included by default, so to test exclusion
1505 -- constraints with range types, use singleton int ranges for the "="
1506 -- portion of the constraint.
1507 --
1508 create table test_range_excl(
1509   room int4range,
1510   speaker int4range,
1511   during tsrange,
1512   exclude using gist (room with =, during with &&),
1513   exclude using gist (speaker with =, during with &&)
1514 );
1515 insert into test_range_excl
1516   values(int4range(123, 123, '[]'), int4range(1, 1, '[]'), '[2010-01-02 10:00, 2010-01-02 11:00)');
1517 insert into test_range_excl
1518   values(int4range(123, 123, '[]'), int4range(2, 2, '[]'), '[2010-01-02 11:00, 2010-01-02 12:00)');
1519 insert into test_range_excl
1520   values(int4range(123, 123, '[]'), int4range(3, 3, '[]'), '[2010-01-02 10:10, 2010-01-02 11:00)');
1521 ERROR:  conflicting key value violates exclusion constraint "test_range_excl_room_during_excl"
1522 DETAIL:  Key (room, during)=([123,124), ["Sat Jan 02 10:10:00 2010","Sat Jan 02 11:00:00 2010")) conflicts with existing key (room, during)=([123,124), ["Sat Jan 02 10:00:00 2010","Sat Jan 02 11:00:00 2010")).
1523 insert into test_range_excl
1524   values(int4range(124, 124, '[]'), int4range(3, 3, '[]'), '[2010-01-02 10:10, 2010-01-02 11:10)');
1525 insert into test_range_excl
1526   values(int4range(125, 125, '[]'), int4range(1, 1, '[]'), '[2010-01-02 10:10, 2010-01-02 11:00)');
1527 ERROR:  conflicting key value violates exclusion constraint "test_range_excl_speaker_during_excl"
1528 DETAIL:  Key (speaker, during)=([1,2), ["Sat Jan 02 10:10:00 2010","Sat Jan 02 11:00:00 2010")) conflicts with existing key (speaker, during)=([1,2), ["Sat Jan 02 10:00:00 2010","Sat Jan 02 11:00:00 2010")).
1529 -- test bigint ranges
1530 select int8range(10000000000::int8, 20000000000::int8,'(]');
1531          int8range
1532 ---------------------------
1533  [10000000001,20000000001)
1534 (1 row)
1535
1536 -- test tstz ranges
1537 set timezone to '-08';
1538 select '[2010-01-01 01:00:00 -05, 2010-01-01 02:00:00 -08)'::tstzrange;
1539                             tstzrange
1540 -----------------------------------------------------------------
1541  ["Thu Dec 31 22:00:00 2009 -08","Fri Jan 01 02:00:00 2010 -08")
1542 (1 row)
1543
1544 -- should fail
1545 select '[2010-01-01 01:00:00 -08, 2010-01-01 02:00:00 -05)'::tstzrange;
1546 ERROR:  range lower bound must be less than or equal to range upper bound
1547 LINE 1: select '[2010-01-01 01:00:00 -08, 2010-01-01 02:00:00 -05)':...
1548                ^
1549 set timezone to default;
1550 --
1551 -- Test user-defined range of floats
1552 -- (type float8range was already made in test_setup.sql)
1553 --
1554 --should fail
1555 create type bogus_float8range as range (subtype=float8, subtype_diff=float4mi);
1556 ERROR:  function float4mi(double precision, double precision) does not exist
1557 select '[123.001, 5.e9)'::float8range @> 888.882::float8;
1558  ?column?
1559 ----------
1560  t
1561 (1 row)
1562
1563 create table float8range_test(f8r float8range, i int);
1564 insert into float8range_test values(float8range(-100.00007, '1.111113e9'), 42);
1565 select * from float8range_test;
1566            f8r           | i
1567 -------------------------+----
1568  [-100.00007,1111113000) | 42
1569 (1 row)
1570
1571 drop table float8range_test;
1572 --
1573 -- Test range types over domains
1574 --
1575 create domain mydomain as int4;
1576 create type mydomainrange as range(subtype=mydomain);
1577 select '[4,50)'::mydomainrange @> 7::mydomain;
1578  ?column?
1579 ----------
1580  t
1581 (1 row)
1582
1583 drop domain mydomain;  -- fail
1584 ERROR:  cannot drop type mydomain because other objects depend on it
1585 DETAIL:  type mydomainrange depends on type mydomain
1586 HINT:  Use DROP ... CASCADE to drop the dependent objects too.
1587 drop domain mydomain cascade;
1588 NOTICE:  drop cascades to type mydomainrange
1589 --
1590 -- Test domains over range types
1591 --
1592 create domain restrictedrange as int4range check (upper(value) < 10);
1593 select '[4,5)'::restrictedrange @> 7;
1594  ?column?
1595 ----------
1596  f
1597 (1 row)
1598
1599 select '[4,50)'::restrictedrange @> 7; -- should fail
1600 ERROR:  value for domain restrictedrange violates check constraint "restrictedrange_check"
1601 drop domain restrictedrange;
1602 --
1603 -- Test multiple range types over the same subtype
1604 --
1605 create type textrange1 as range(subtype=text, collation="C");
1606 create type textrange2 as range(subtype=text, collation="C");
1607 select textrange1('a','Z') @> 'b'::text;
1608 ERROR:  range lower bound must be less than or equal to range upper bound
1609 select textrange2('a','z') @> 'b'::text;
1610  ?column?
1611 ----------
1612  t
1613 (1 row)
1614
1615 drop type textrange1;
1616 drop type textrange2;
1617 --
1618 -- Test polymorphic type system
1619 --
1620 create function anyarray_anyrange_func(a anyarray, r anyrange)
1621   returns anyelement as 'select $1[1] + lower($2);' language sql;
1622 select anyarray_anyrange_func(ARRAY[1,2], int4range(10,20));
1623  anyarray_anyrange_func
1624 ------------------------
1625                      11
1626 (1 row)
1627
1628 -- should fail
1629 select anyarray_anyrange_func(ARRAY[1,2], numrange(10,20));
1630 ERROR:  function anyarray_anyrange_func(integer[], numrange) does not exist
1631 LINE 1: select anyarray_anyrange_func(ARRAY[1,2], numrange(10,20));
1632                ^
1633 HINT:  No function matches the given name and argument types. You might need to add explicit type casts.
1634 drop function anyarray_anyrange_func(anyarray, anyrange);
1635 -- should fail
1636 create function bogus_func(anyelement)
1637   returns anyrange as 'select int4range(1,10)' language sql;
1638 ERROR:  cannot determine result data type
1639 DETAIL:  A result of type anyrange requires at least one input of type anyrange or anymultirange.
1640 -- should fail
1641 create function bogus_func(int)
1642   returns anyrange as 'select int4range(1,10)' language sql;
1643 ERROR:  cannot determine result data type
1644 DETAIL:  A result of type anyrange requires at least one input of type anyrange or anymultirange.
1645 create function range_add_bounds(anyrange)
1646   returns anyelement as 'select lower($1) + upper($1)' language sql;
1647 select range_add_bounds(int4range(1, 17));
1648  range_add_bounds
1649 ------------------
1650                18
1651 (1 row)
1652
1653 select range_add_bounds(numrange(1.0001, 123.123));
1654  range_add_bounds
1655 ------------------
1656          124.1231
1657 (1 row)
1658
1659 create function rangetypes_sql(q anyrange, b anyarray, out c anyelement)
1660   as $$ select upper($1) + $2[1] $$
1661   language sql;
1662 select rangetypes_sql(int4range(1,10), ARRAY[2,20]);
1663  rangetypes_sql
1664 ----------------
1665              12
1666 (1 row)
1667
1668 select rangetypes_sql(numrange(1,10), ARRAY[2,20]);  -- match failure
1669 ERROR:  function rangetypes_sql(numrange, integer[]) does not exist
1670 LINE 1: select rangetypes_sql(numrange(1,10), ARRAY[2,20]);
1671                ^
1672 HINT:  No function matches the given name and argument types. You might need to add explicit type casts.
1673 create function anycompatiblearray_anycompatiblerange_func(a anycompatiblearray, r anycompatiblerange)
1674   returns anycompatible as 'select $1[1] + lower($2);' language sql;
1675 select anycompatiblearray_anycompatiblerange_func(ARRAY[1,2], int4range(10,20));
1676  anycompatiblearray_anycompatiblerange_func
1677 --------------------------------------------
1678                                          11
1679 (1 row)
1680
1681 select anycompatiblearray_anycompatiblerange_func(ARRAY[1,2], numrange(10,20));
1682  anycompatiblearray_anycompatiblerange_func
1683 --------------------------------------------
1684                                          11
1685 (1 row)
1686
1687 -- should fail
1688 select anycompatiblearray_anycompatiblerange_func(ARRAY[1.1,2], int4range(10,20));
1689 ERROR:  function anycompatiblearray_anycompatiblerange_func(numeric[], int4range) does not exist
1690 LINE 1: select anycompatiblearray_anycompatiblerange_func(ARRAY[1.1,...
1691                ^
1692 HINT:  No function matches the given name and argument types. You might need to add explicit type casts.
1693 drop function anycompatiblearray_anycompatiblerange_func(anycompatiblearray, anycompatiblerange);
1694 -- should fail
1695 create function bogus_func(anycompatible)
1696   returns anycompatiblerange as 'select int4range(1,10)' language sql;
1697 ERROR:  cannot determine result data type
1698 DETAIL:  A result of type anycompatiblerange requires at least one input of type anycompatiblerange or anycompatiblemultirange.
1699 --
1700 -- Arrays of ranges
1701 --
1702 select ARRAY[numrange(1.1, 1.2), numrange(12.3, 155.5)];
1703             array
1704 ------------------------------
1705  {"[1.1,1.2)","[12.3,155.5)"}
1706 (1 row)
1707
1708 create table i8r_array (f1 int, f2 int8range[]);
1709 insert into i8r_array values (42, array[int8range(1,10), int8range(2,20)]);
1710 select * from i8r_array;
1711  f1 |         f2
1712 ----+---------------------
1713  42 | {"[1,10)","[2,20)"}
1714 (1 row)
1715
1716 drop table i8r_array;
1717 --
1718 -- Ranges of arrays
1719 --
1720 create type arrayrange as range (subtype=int4[]);
1721 select arrayrange(ARRAY[1,2], ARRAY[2,1]);
1722     arrayrange
1723 -------------------
1724  ["{1,2}","{2,1}")
1725 (1 row)
1726
1727 select arrayrange(ARRAY[2,1], ARRAY[1,2]);  -- fail
1728 ERROR:  range lower bound must be less than or equal to range upper bound
1729 select array[1,1] <@ arrayrange(array[1,2], array[2,1]);
1730  ?column?
1731 ----------
1732  f
1733 (1 row)
1734
1735 select array[1,3] <@ arrayrange(array[1,2], array[2,1]);
1736  ?column?
1737 ----------
1738  t
1739 (1 row)
1740
1741 --
1742 -- Ranges of composites
1743 --
1744 create type two_ints as (a int, b int);
1745 create type two_ints_range as range (subtype = two_ints);
1746 -- with debug_parallel_query on, this exercises tqueue.c's range remapping
1747 select *, row_to_json(upper(t)) as u from
1748   (values (two_ints_range(row(1,2), row(3,4))),
1749           (two_ints_range(row(5,6), row(7,8)))) v(t);
1750          t         |       u
1751 -------------------+---------------
1752  ["(1,2)","(3,4)") | {"a":3,"b":4}
1753  ["(5,6)","(7,8)") | {"a":7,"b":8}
1754 (2 rows)
1755
1756 -- this must be rejected to avoid self-inclusion issues:
1757 alter type two_ints add attribute c two_ints_range;
1758 ERROR:  composite type two_ints cannot be made a member of itself
1759 drop type two_ints cascade;
1760 NOTICE:  drop cascades to type two_ints_range
1761 --
1762 -- Check behavior when subtype lacks a hash function
1763 --
1764 create type varbitrange as range (subtype = varbit);
1765 set enable_sort = off;  -- try to make it pick a hash setop implementation
1766 select '(01,10)'::varbitrange except select '(10,11)'::varbitrange;
1767  varbitrange
1768 -------------
1769  (01,10)
1770 (1 row)
1771
1772 reset enable_sort;
1773 --
1774 -- OUT/INOUT/TABLE functions
1775 --
1776 -- infer anyrange from anyrange
1777 create function outparam_succeed(i anyrange, out r anyrange, out t text)
1778   as $$ select $1, 'foo'::text $$ language sql;
1779 select * from outparam_succeed(int4range(1,2));
1780    r   |  t
1781 -------+-----
1782  [1,2) | foo
1783 (1 row)
1784
1785 create function outparam2_succeed(r anyrange, out lu anyarray, out ul anyarray)
1786   as $$ select array[lower($1), upper($1)], array[upper($1), lower($1)] $$
1787   language sql;
1788 select * from outparam2_succeed(int4range(1,11));
1789    lu   |   ul
1790 --------+--------
1791  {1,11} | {11,1}
1792 (1 row)
1793
1794 -- infer anyarray from anyrange
1795 create function outparam_succeed2(i anyrange, out r anyarray, out t text)
1796   as $$ select ARRAY[upper($1)], 'foo'::text $$ language sql;
1797 select * from outparam_succeed2(int4range(int4range(1,2)));
1798   r  |  t
1799 -----+-----
1800  {2} | foo
1801 (1 row)
1802
1803 -- infer anyelement from anyrange
1804 create function inoutparam_succeed(out i anyelement, inout r anyrange)
1805   as $$ select upper($1), $1 $$ language sql;
1806 select * from inoutparam_succeed(int4range(1,2));
1807  i |   r
1808 ---+-------
1809  2 | [1,2)
1810 (1 row)
1811
1812 create function table_succeed(r anyrange)
1813   returns table(l anyelement, u anyelement)
1814   as $$ select lower($1), upper($1) $$
1815   language sql;
1816 select * from table_succeed(int4range(1,11));
1817  l | u
1818 ---+----
1819  1 | 11
1820 (1 row)
1821
1822 -- should fail
1823 create function outparam_fail(i anyelement, out r anyrange, out t text)
1824   as $$ select '[1,10]', 'foo' $$ language sql;
1825 ERROR:  cannot determine result data type
1826 DETAIL:  A result of type anyrange requires at least one input of type anyrange or anymultirange.
1827 --should fail
1828 create function inoutparam_fail(inout i anyelement, out r anyrange)
1829   as $$ select $1, '[1,10]' $$ language sql;
1830 ERROR:  cannot determine result data type
1831 DETAIL:  A result of type anyrange requires at least one input of type anyrange or anymultirange.
1832 --should fail
1833 create function table_fail(i anyelement) returns table(i anyelement, r anyrange)
1834   as $$ select $1, '[1,10]' $$ language sql;
1835 ERROR:  cannot determine result data type
1836 DETAIL:  A result of type anyrange requires at least one input of type anyrange or anymultirange.
1837 --
1838 -- Test support functions
1839 --
1840 -- empty range
1841 explain (verbose, costs off)
1842 select current_date <@ daterange 'empty';
1843    QUERY PLAN
1844 -----------------
1845  Result
1846    Output: false
1847 (2 rows)
1848
1849 -- unbounded range
1850 explain (verbose, costs off)
1851 select current_date <@ daterange(NULL, NULL);
1852    QUERY PLAN
1853 ----------------
1854  Result
1855    Output: true
1856 (2 rows)
1857
1858 -- only lower bound present
1859 explain (verbose, costs off)
1860 select current_date <@ daterange('2000-01-01', NULL, '[)');
1861                    QUERY PLAN
1862 ------------------------------------------------
1863  Result
1864    Output: (CURRENT_DATE >= '01-01-2000'::date)
1865 (2 rows)
1866
1867 -- only upper bound present
1868 explain (verbose, costs off)
1869 select current_date <@ daterange(NULL, '2000-01-01', '(]');
1870                   QUERY PLAN
1871 -----------------------------------------------
1872  Result
1873    Output: (CURRENT_DATE < '01-02-2000'::date)
1874 (2 rows)
1875
1876 -- lower range "-Infinity" excluded
1877 explain (verbose, costs off)
1878 select current_date <@ daterange('-Infinity', '1997-04-10'::date, '()');
1879                                        QUERY PLAN
1880 ----------------------------------------------------------------------------------------
1881  Result
1882    Output: ((CURRENT_DATE > '-infinity'::date) AND (CURRENT_DATE < '04-10-1997'::date))
1883 (2 rows)
1884
1885 -- lower range "-Infinity" included
1886 explain (verbose, costs off)
1887 select current_date <@ daterange('-Infinity', '1997-04-10'::date, '[)');
1888                                        QUERY PLAN
1889 -----------------------------------------------------------------------------------------
1890  Result
1891    Output: ((CURRENT_DATE >= '-infinity'::date) AND (CURRENT_DATE < '04-10-1997'::date))
1892 (2 rows)
1893
1894 -- upper range "Infinity" excluded
1895 explain (verbose, costs off)
1896 select current_date <@ daterange('2002-09-25'::date, 'Infinity', '[)');
1897                                        QUERY PLAN
1898 ----------------------------------------------------------------------------------------
1899  Result
1900    Output: ((CURRENT_DATE >= '09-25-2002'::date) AND (CURRENT_DATE < 'infinity'::date))
1901 (2 rows)
1902
1903 -- upper range "Infinity" included
1904 explain (verbose, costs off)
1905 select current_date <@ daterange('2002-09-25'::date, 'Infinity', '[]');
1906                                        QUERY PLAN
1907 -----------------------------------------------------------------------------------------
1908  Result
1909    Output: ((CURRENT_DATE >= '09-25-2002'::date) AND (CURRENT_DATE <= 'infinity'::date))
1910 (2 rows)
1911
1912 -- should also work if we use "@>"
1913 explain (verbose, costs off)
1914 select daterange('-Infinity', '1997-04-10'::date, '()') @> current_date;
1915                                        QUERY PLAN
1916 ----------------------------------------------------------------------------------------
1917  Result
1918    Output: ((CURRENT_DATE > '-infinity'::date) AND (CURRENT_DATE < '04-10-1997'::date))
1919 (2 rows)
1920
1921 explain (verbose, costs off)
1922 select daterange('2002-09-25'::date, 'Infinity', '[]') @> current_date;
1923                                        QUERY PLAN
1924 -----------------------------------------------------------------------------------------
1925  Result
1926    Output: ((CURRENT_DATE >= '09-25-2002'::date) AND (CURRENT_DATE <= 'infinity'::date))
1927 (2 rows)
1928
1929 -- Check that volatile cases are not optimized
1930 explain (verbose, costs off)
1931 select now() <@ tstzrange('2024-01-20 00:00', '2024-01-21 00:00');
1932                                                                        QUERY PLAN
1933 --------------------------------------------------------------------------------------------------------------------------------------------------------
1934  Result
1935    Output: ((now() >= 'Sat Jan 20 00:00:00 2024 PST'::timestamp with time zone) AND (now() < 'Sun Jan 21 00:00:00 2024 PST'::timestamp with time zone))
1936 (2 rows)
1937
1938 explain (verbose, costs off)  -- unsafe!
1939 select clock_timestamp() <@ tstzrange('2024-01-20 00:00', '2024-01-21 00:00');
1940                                                   QUERY PLAN
1941 ---------------------------------------------------------------------------------------------------------------
1942  Result
1943    Output: (clock_timestamp() <@ '["Sat Jan 20 00:00:00 2024 PST","Sun Jan 21 00:00:00 2024 PST")'::tstzrange)
1944 (2 rows)
1945
1946 explain (verbose, costs off)
1947 select clock_timestamp() <@ tstzrange('2024-01-20 00:00', NULL);
1948                                         QUERY PLAN
1949 -------------------------------------------------------------------------------------------
1950  Result
1951    Output: (clock_timestamp() >= 'Sat Jan 20 00:00:00 2024 PST'::timestamp with time zone)
1952 (2 rows)
1953
1954 -- test a custom range type with a non-default operator class
1955 create type textrange_supp as range (
1956    subtype = text,
1957    subtype_opclass = text_pattern_ops
1958 );
1959 create temp table text_support_test (t text collate "C");
1960 insert into text_support_test values ('a'), ('c'), ('d'), ('ch');
1961 explain (costs off)
1962 select * from text_support_test where t <@ textrange_supp('a', 'd');
1963                       QUERY PLAN
1964 ------------------------------------------------------
1965  Seq Scan on text_support_test
1966    Filter: ((t ~>=~ 'a'::text) AND (t ~<~ 'd'::text))
1967 (2 rows)
1968
1969 select * from text_support_test where t <@ textrange_supp('a', 'd');
1970  t
1971 ----
1972  a
1973  c
1974  ch
1975 (3 rows)
1976
1977 drop table text_support_test;
1978 drop type textrange_supp;