1/* contrib/isn/isn--1.1.sql */ 2 3-- complain if script is sourced in psql, rather than via CREATE EXTENSION 4\echo Use "CREATE EXTENSION isn" to load this file. \quit 5 6-- Example: 7-- create table test ( id isbn ); 8-- insert into test values('978-0-393-04002-9'); 9-- 10-- select isbn('978-0-393-04002-9'); 11-- select isbn13('0-901690-54-6'); 12-- 13 14-- 15-- Input and output functions and data types: 16-- 17--------------------------------------------------- 18CREATE FUNCTION ean13_in(cstring) 19 RETURNS ean13 20 AS 'MODULE_PATHNAME' 21 LANGUAGE C 22 IMMUTABLE STRICT 23 PARALLEL SAFE; 24CREATE FUNCTION ean13_out(ean13) 25 RETURNS cstring 26 AS 'MODULE_PATHNAME' 27 LANGUAGE C 28 IMMUTABLE STRICT 29 PARALLEL SAFE; 30CREATE TYPE ean13 ( 31 INPUT = ean13_in, 32 OUTPUT = ean13_out, 33 LIKE = pg_catalog.int8 34); 35COMMENT ON TYPE ean13 36 IS 'International European Article Number (EAN13)'; 37 38CREATE FUNCTION isbn13_in(cstring) 39 RETURNS isbn13 40 AS 'MODULE_PATHNAME', 'isbn_in' 41 LANGUAGE C 42 IMMUTABLE STRICT 43 PARALLEL SAFE; 44CREATE FUNCTION ean13_out(isbn13) 45 RETURNS cstring 46 AS 'MODULE_PATHNAME' 47 LANGUAGE C 48 IMMUTABLE STRICT 49 PARALLEL SAFE; 50CREATE TYPE isbn13 ( 51 INPUT = isbn13_in, 52 OUTPUT = ean13_out, 53 LIKE = pg_catalog.int8 54); 55COMMENT ON TYPE isbn13 56 IS 'International Standard Book Number 13 (ISBN13)'; 57 58CREATE FUNCTION ismn13_in(cstring) 59 RETURNS ismn13 60 AS 'MODULE_PATHNAME', 'ismn_in' 61 LANGUAGE C 62 IMMUTABLE STRICT 63 PARALLEL SAFE; 64CREATE FUNCTION ean13_out(ismn13) 65 RETURNS cstring 66 AS 'MODULE_PATHNAME' 67 LANGUAGE C 68 IMMUTABLE STRICT 69 PARALLEL SAFE; 70CREATE TYPE ismn13 ( 71 INPUT = ismn13_in, 72 OUTPUT = ean13_out, 73 LIKE = pg_catalog.int8 74); 75COMMENT ON TYPE ismn13 76 IS 'International Standard Music Number 13 (ISMN13)'; 77 78CREATE FUNCTION issn13_in(cstring) 79 RETURNS issn13 80 AS 'MODULE_PATHNAME', 'issn_in' 81 LANGUAGE C 82 IMMUTABLE STRICT 83 PARALLEL SAFE; 84CREATE FUNCTION ean13_out(issn13) 85 RETURNS cstring 86 AS 'MODULE_PATHNAME' 87 LANGUAGE C 88 IMMUTABLE STRICT 89 PARALLEL SAFE; 90CREATE TYPE issn13 ( 91 INPUT = issn13_in, 92 OUTPUT = ean13_out, 93 LIKE = pg_catalog.int8 94); 95COMMENT ON TYPE issn13 96 IS 'International Standard Serial Number 13 (ISSN13)'; 97 98-- Short format: 99 100CREATE FUNCTION isbn_in(cstring) 101 RETURNS isbn 102 AS 'MODULE_PATHNAME' 103 LANGUAGE C 104 IMMUTABLE STRICT 105 PARALLEL SAFE; 106CREATE FUNCTION isn_out(isbn) 107 RETURNS cstring 108 AS 'MODULE_PATHNAME' 109 LANGUAGE C 110 IMMUTABLE STRICT 111 PARALLEL SAFE; 112CREATE TYPE isbn ( 113 INPUT = isbn_in, 114 OUTPUT = isn_out, 115 LIKE = pg_catalog.int8 116); 117COMMENT ON TYPE isbn 118 IS 'International Standard Book Number (ISBN)'; 119 120CREATE FUNCTION ismn_in(cstring) 121 RETURNS ismn 122 AS 'MODULE_PATHNAME' 123 LANGUAGE C 124 IMMUTABLE STRICT 125 PARALLEL SAFE; 126CREATE FUNCTION isn_out(ismn) 127 RETURNS cstring 128 AS 'MODULE_PATHNAME' 129 LANGUAGE C 130 IMMUTABLE STRICT 131 PARALLEL SAFE; 132CREATE TYPE ismn ( 133 INPUT = ismn_in, 134 OUTPUT = isn_out, 135 LIKE = pg_catalog.int8 136); 137COMMENT ON TYPE ismn 138 IS 'International Standard Music Number (ISMN)'; 139 140CREATE FUNCTION issn_in(cstring) 141 RETURNS issn 142 AS 'MODULE_PATHNAME' 143 LANGUAGE C 144 IMMUTABLE STRICT 145 PARALLEL SAFE; 146CREATE FUNCTION isn_out(issn) 147 RETURNS cstring 148 AS 'MODULE_PATHNAME' 149 LANGUAGE C 150 IMMUTABLE STRICT 151 PARALLEL SAFE; 152CREATE TYPE issn ( 153 INPUT = issn_in, 154 OUTPUT = isn_out, 155 LIKE = pg_catalog.int8 156); 157COMMENT ON TYPE issn 158 IS 'International Standard Serial Number (ISSN)'; 159 160CREATE FUNCTION upc_in(cstring) 161 RETURNS upc 162 AS 'MODULE_PATHNAME' 163 LANGUAGE C 164 IMMUTABLE STRICT 165 PARALLEL SAFE; 166CREATE FUNCTION isn_out(upc) 167 RETURNS cstring 168 AS 'MODULE_PATHNAME' 169 LANGUAGE C 170 IMMUTABLE STRICT 171 PARALLEL SAFE; 172CREATE TYPE upc ( 173 INPUT = upc_in, 174 OUTPUT = isn_out, 175 LIKE = pg_catalog.int8 176); 177COMMENT ON TYPE upc 178 IS 'Universal Product Code (UPC)'; 179 180-- 181-- Operator functions: 182-- 183--------------------------------------------------- 184-- EAN13: 185CREATE FUNCTION isnlt(ean13, ean13) 186 RETURNS boolean 187 AS 'int8lt' 188 LANGUAGE 'internal' 189 IMMUTABLE STRICT 190 PARALLEL SAFE; 191CREATE FUNCTION isnle(ean13, ean13) 192 RETURNS boolean 193 AS 'int8le' 194 LANGUAGE 'internal' 195 IMMUTABLE STRICT 196 PARALLEL SAFE; 197CREATE FUNCTION isneq(ean13, ean13) 198 RETURNS boolean 199 AS 'int8eq' 200 LANGUAGE 'internal' 201 IMMUTABLE STRICT 202 PARALLEL SAFE; 203CREATE FUNCTION isnge(ean13, ean13) 204 RETURNS boolean 205 AS 'int8ge' 206 LANGUAGE 'internal' 207 IMMUTABLE STRICT 208 PARALLEL SAFE; 209CREATE FUNCTION isngt(ean13, ean13) 210 RETURNS boolean 211 AS 'int8gt' 212 LANGUAGE 'internal' 213 IMMUTABLE STRICT 214 PARALLEL SAFE; 215CREATE FUNCTION isnne(ean13, ean13) 216 RETURNS boolean 217 AS 'int8ne' 218 LANGUAGE 'internal' 219 IMMUTABLE STRICT 220 PARALLEL SAFE; 221 222CREATE FUNCTION isnlt(ean13, isbn13) 223 RETURNS boolean 224 AS 'int8lt' 225 LANGUAGE 'internal' 226 IMMUTABLE STRICT 227 PARALLEL SAFE; 228CREATE FUNCTION isnle(ean13, isbn13) 229 RETURNS boolean 230 AS 'int8le' 231 LANGUAGE 'internal' 232 IMMUTABLE STRICT 233 PARALLEL SAFE; 234CREATE FUNCTION isneq(ean13, isbn13) 235 RETURNS boolean 236 AS 'int8eq' 237 LANGUAGE 'internal' 238 IMMUTABLE STRICT 239 PARALLEL SAFE; 240CREATE FUNCTION isnge(ean13, isbn13) 241 RETURNS boolean 242 AS 'int8ge' 243 LANGUAGE 'internal' 244 IMMUTABLE STRICT 245 PARALLEL SAFE; 246CREATE FUNCTION isngt(ean13, isbn13) 247 RETURNS boolean 248 AS 'int8gt' 249 LANGUAGE 'internal' 250 IMMUTABLE STRICT 251 PARALLEL SAFE; 252CREATE FUNCTION isnne(ean13, isbn13) 253 RETURNS boolean 254 AS 'int8ne' 255 LANGUAGE 'internal' 256 IMMUTABLE STRICT 257 PARALLEL SAFE; 258 259CREATE FUNCTION isnlt(ean13, ismn13) 260 RETURNS boolean 261 AS 'int8lt' 262 LANGUAGE 'internal' 263 IMMUTABLE STRICT 264 PARALLEL SAFE; 265CREATE FUNCTION isnle(ean13, ismn13) 266 RETURNS boolean 267 AS 'int8le' 268 LANGUAGE 'internal' 269 IMMUTABLE STRICT 270 PARALLEL SAFE; 271CREATE FUNCTION isneq(ean13, ismn13) 272 RETURNS boolean 273 AS 'int8eq' 274 LANGUAGE 'internal' 275 IMMUTABLE STRICT 276 PARALLEL SAFE; 277CREATE FUNCTION isnge(ean13, ismn13) 278 RETURNS boolean 279 AS 'int8ge' 280 LANGUAGE 'internal' 281 IMMUTABLE STRICT 282 PARALLEL SAFE; 283CREATE FUNCTION isngt(ean13, ismn13) 284 RETURNS boolean 285 AS 'int8gt' 286 LANGUAGE 'internal' 287 IMMUTABLE STRICT 288 PARALLEL SAFE; 289CREATE FUNCTION isnne(ean13, ismn13) 290 RETURNS boolean 291 AS 'int8ne' 292 LANGUAGE 'internal' 293 IMMUTABLE STRICT 294 PARALLEL SAFE; 295 296CREATE FUNCTION isnlt(ean13, issn13) 297 RETURNS boolean 298 AS 'int8lt' 299 LANGUAGE 'internal' 300 IMMUTABLE STRICT 301 PARALLEL SAFE; 302CREATE FUNCTION isnle(ean13, issn13) 303 RETURNS boolean 304 AS 'int8le' 305 LANGUAGE 'internal' 306 IMMUTABLE STRICT 307 PARALLEL SAFE; 308CREATE FUNCTION isneq(ean13, issn13) 309 RETURNS boolean 310 AS 'int8eq' 311 LANGUAGE 'internal' 312 IMMUTABLE STRICT 313 PARALLEL SAFE; 314CREATE FUNCTION isnge(ean13, issn13) 315 RETURNS boolean 316 AS 'int8ge' 317 LANGUAGE 'internal' 318 IMMUTABLE STRICT 319 PARALLEL SAFE; 320CREATE FUNCTION isngt(ean13, issn13) 321 RETURNS boolean 322 AS 'int8gt' 323 LANGUAGE 'internal' 324 IMMUTABLE STRICT 325 PARALLEL SAFE; 326CREATE FUNCTION isnne(ean13, issn13) 327 RETURNS boolean 328 AS 'int8ne' 329 LANGUAGE 'internal' 330 IMMUTABLE STRICT 331 PARALLEL SAFE; 332 333CREATE FUNCTION isnlt(ean13, isbn) 334 RETURNS boolean 335 AS 'int8lt' 336 LANGUAGE 'internal' 337 IMMUTABLE STRICT 338 PARALLEL SAFE; 339CREATE FUNCTION isnle(ean13, isbn) 340 RETURNS boolean 341 AS 'int8le' 342 LANGUAGE 'internal' 343 IMMUTABLE STRICT 344 PARALLEL SAFE; 345CREATE FUNCTION isneq(ean13, isbn) 346 RETURNS boolean 347 AS 'int8eq' 348 LANGUAGE 'internal' 349 IMMUTABLE STRICT 350 PARALLEL SAFE; 351CREATE FUNCTION isnge(ean13, isbn) 352 RETURNS boolean 353 AS 'int8ge' 354 LANGUAGE 'internal' 355 IMMUTABLE STRICT 356 PARALLEL SAFE; 357CREATE FUNCTION isngt(ean13, isbn) 358 RETURNS boolean 359 AS 'int8gt' 360 LANGUAGE 'internal' 361 IMMUTABLE STRICT 362 PARALLEL SAFE; 363CREATE FUNCTION isnne(ean13, isbn) 364 RETURNS boolean 365 AS 'int8ne' 366 LANGUAGE 'internal' 367 IMMUTABLE STRICT 368 PARALLEL SAFE; 369 370CREATE FUNCTION isnlt(ean13, ismn) 371 RETURNS boolean 372 AS 'int8lt' 373 LANGUAGE 'internal' 374 IMMUTABLE STRICT 375 PARALLEL SAFE; 376CREATE FUNCTION isnle(ean13, ismn) 377 RETURNS boolean 378 AS 'int8le' 379 LANGUAGE 'internal' 380 IMMUTABLE STRICT 381 PARALLEL SAFE; 382CREATE FUNCTION isneq(ean13, ismn) 383 RETURNS boolean 384 AS 'int8eq' 385 LANGUAGE 'internal' 386 IMMUTABLE STRICT 387 PARALLEL SAFE; 388CREATE FUNCTION isnge(ean13, ismn) 389 RETURNS boolean 390 AS 'int8ge' 391 LANGUAGE 'internal' 392 IMMUTABLE STRICT 393 PARALLEL SAFE; 394CREATE FUNCTION isngt(ean13, ismn) 395 RETURNS boolean 396 AS 'int8gt' 397 LANGUAGE 'internal' 398 IMMUTABLE STRICT 399 PARALLEL SAFE; 400CREATE FUNCTION isnne(ean13, ismn) 401 RETURNS boolean 402 AS 'int8ne' 403 LANGUAGE 'internal' 404 IMMUTABLE STRICT 405 PARALLEL SAFE; 406 407CREATE FUNCTION isnlt(ean13, issn) 408 RETURNS boolean 409 AS 'int8lt' 410 LANGUAGE 'internal' 411 IMMUTABLE STRICT 412 PARALLEL SAFE; 413CREATE FUNCTION isnle(ean13, issn) 414 RETURNS boolean 415 AS 'int8le' 416 LANGUAGE 'internal' 417 IMMUTABLE STRICT 418 PARALLEL SAFE; 419CREATE FUNCTION isneq(ean13, issn) 420 RETURNS boolean 421 AS 'int8eq' 422 LANGUAGE 'internal' 423 IMMUTABLE STRICT 424 PARALLEL SAFE; 425CREATE FUNCTION isnge(ean13, issn) 426 RETURNS boolean 427 AS 'int8ge' 428 LANGUAGE 'internal' 429 IMMUTABLE STRICT 430 PARALLEL SAFE; 431CREATE FUNCTION isngt(ean13, issn) 432 RETURNS boolean 433 AS 'int8gt' 434 LANGUAGE 'internal' 435 IMMUTABLE STRICT 436 PARALLEL SAFE; 437CREATE FUNCTION isnne(ean13, issn) 438 RETURNS boolean 439 AS 'int8ne' 440 LANGUAGE 'internal' 441 IMMUTABLE STRICT 442 PARALLEL SAFE; 443 444CREATE FUNCTION isnlt(ean13, upc) 445 RETURNS boolean 446 AS 'int8lt' 447 LANGUAGE 'internal' 448 IMMUTABLE STRICT 449 PARALLEL SAFE; 450CREATE FUNCTION isnle(ean13, upc) 451 RETURNS boolean 452 AS 'int8le' 453 LANGUAGE 'internal' 454 IMMUTABLE STRICT 455 PARALLEL SAFE; 456CREATE FUNCTION isneq(ean13, upc) 457 RETURNS boolean 458 AS 'int8eq' 459 LANGUAGE 'internal' 460 IMMUTABLE STRICT 461 PARALLEL SAFE; 462CREATE FUNCTION isnge(ean13, upc) 463 RETURNS boolean 464 AS 'int8ge' 465 LANGUAGE 'internal' 466 IMMUTABLE STRICT 467 PARALLEL SAFE; 468CREATE FUNCTION isngt(ean13, upc) 469 RETURNS boolean 470 AS 'int8gt' 471 LANGUAGE 'internal' 472 IMMUTABLE STRICT 473 PARALLEL SAFE; 474CREATE FUNCTION isnne(ean13, upc) 475 RETURNS boolean 476 AS 'int8ne' 477 LANGUAGE 'internal' 478 IMMUTABLE STRICT 479 PARALLEL SAFE; 480 481--------------------------------------------------- 482-- ISBN13: 483CREATE FUNCTION isnlt(isbn13, isbn13) 484 RETURNS boolean 485 AS 'int8lt' 486 LANGUAGE 'internal' 487 IMMUTABLE STRICT 488 PARALLEL SAFE; 489CREATE FUNCTION isnle(isbn13, isbn13) 490 RETURNS boolean 491 AS 'int8le' 492 LANGUAGE 'internal' 493 IMMUTABLE STRICT 494 PARALLEL SAFE; 495CREATE FUNCTION isneq(isbn13, isbn13) 496 RETURNS boolean 497 AS 'int8eq' 498 LANGUAGE 'internal' 499 IMMUTABLE STRICT 500 PARALLEL SAFE; 501CREATE FUNCTION isnge(isbn13, isbn13) 502 RETURNS boolean 503 AS 'int8ge' 504 LANGUAGE 'internal' 505 IMMUTABLE STRICT 506 PARALLEL SAFE; 507CREATE FUNCTION isngt(isbn13, isbn13) 508 RETURNS boolean 509 AS 'int8gt' 510 LANGUAGE 'internal' 511 IMMUTABLE STRICT 512 PARALLEL SAFE; 513CREATE FUNCTION isnne(isbn13, isbn13) 514 RETURNS boolean 515 AS 'int8ne' 516 LANGUAGE 'internal' 517 IMMUTABLE STRICT 518 PARALLEL SAFE; 519 520CREATE FUNCTION isnlt(isbn13, isbn) 521 RETURNS boolean 522 AS 'int8lt' 523 LANGUAGE 'internal' 524 IMMUTABLE STRICT 525 PARALLEL SAFE; 526CREATE FUNCTION isnle(isbn13, isbn) 527 RETURNS boolean 528 AS 'int8le' 529 LANGUAGE 'internal' 530 IMMUTABLE STRICT 531 PARALLEL SAFE; 532CREATE FUNCTION isneq(isbn13, isbn) 533 RETURNS boolean 534 AS 'int8eq' 535 LANGUAGE 'internal' 536 IMMUTABLE STRICT 537 PARALLEL SAFE; 538CREATE FUNCTION isnge(isbn13, isbn) 539 RETURNS boolean 540 AS 'int8ge' 541 LANGUAGE 'internal' 542 IMMUTABLE STRICT 543 PARALLEL SAFE; 544CREATE FUNCTION isngt(isbn13, isbn) 545 RETURNS boolean 546 AS 'int8gt' 547 LANGUAGE 'internal' 548 IMMUTABLE STRICT 549 PARALLEL SAFE; 550CREATE FUNCTION isnne(isbn13, isbn) 551 RETURNS boolean 552 AS 'int8ne' 553 LANGUAGE 'internal' 554 IMMUTABLE STRICT 555 PARALLEL SAFE; 556 557CREATE FUNCTION isnlt(isbn13, ean13) 558 RETURNS boolean 559 AS 'int8lt' 560 LANGUAGE 'internal' 561 IMMUTABLE STRICT 562 PARALLEL SAFE; 563CREATE FUNCTION isnle(isbn13, ean13) 564 RETURNS boolean 565 AS 'int8le' 566 LANGUAGE 'internal' 567 IMMUTABLE STRICT 568 PARALLEL SAFE; 569CREATE FUNCTION isneq(isbn13, ean13) 570 RETURNS boolean 571 AS 'int8eq' 572 LANGUAGE 'internal' 573 IMMUTABLE STRICT 574 PARALLEL SAFE; 575CREATE FUNCTION isnge(isbn13, ean13) 576 RETURNS boolean 577 AS 'int8ge' 578 LANGUAGE 'internal' 579 IMMUTABLE STRICT 580 PARALLEL SAFE; 581CREATE FUNCTION isngt(isbn13, ean13) 582 RETURNS boolean 583 AS 'int8gt' 584 LANGUAGE 'internal' 585 IMMUTABLE STRICT 586 PARALLEL SAFE; 587CREATE FUNCTION isnne(isbn13, ean13) 588 RETURNS boolean 589 AS 'int8ne' 590 LANGUAGE 'internal' 591 IMMUTABLE STRICT 592 PARALLEL SAFE; 593 594--------------------------------------------------- 595-- ISBN: 596CREATE FUNCTION isnlt(isbn, isbn) 597 RETURNS boolean 598 AS 'int8lt' 599 LANGUAGE 'internal' 600 IMMUTABLE STRICT 601 PARALLEL SAFE; 602CREATE FUNCTION isnle(isbn, isbn) 603 RETURNS boolean 604 AS 'int8le' 605 LANGUAGE 'internal' 606 IMMUTABLE STRICT 607 PARALLEL SAFE; 608CREATE FUNCTION isneq(isbn, isbn) 609 RETURNS boolean 610 AS 'int8eq' 611 LANGUAGE 'internal' 612 IMMUTABLE STRICT 613 PARALLEL SAFE; 614CREATE FUNCTION isnge(isbn, isbn) 615 RETURNS boolean 616 AS 'int8ge' 617 LANGUAGE 'internal' 618 IMMUTABLE STRICT 619 PARALLEL SAFE; 620CREATE FUNCTION isngt(isbn, isbn) 621 RETURNS boolean 622 AS 'int8gt' 623 LANGUAGE 'internal' 624 IMMUTABLE STRICT 625 PARALLEL SAFE; 626CREATE FUNCTION isnne(isbn, isbn) 627 RETURNS boolean 628 AS 'int8ne' 629 LANGUAGE 'internal' 630 IMMUTABLE STRICT 631 PARALLEL SAFE; 632 633CREATE FUNCTION isnlt(isbn, isbn13) 634 RETURNS boolean 635 AS 'int8lt' 636 LANGUAGE 'internal' 637 IMMUTABLE STRICT 638 PARALLEL SAFE; 639CREATE FUNCTION isnle(isbn, isbn13) 640 RETURNS boolean 641 AS 'int8le' 642 LANGUAGE 'internal' 643 IMMUTABLE STRICT 644 PARALLEL SAFE; 645CREATE FUNCTION isneq(isbn, isbn13) 646 RETURNS boolean 647 AS 'int8eq' 648 LANGUAGE 'internal' 649 IMMUTABLE STRICT 650 PARALLEL SAFE; 651CREATE FUNCTION isnge(isbn, isbn13) 652 RETURNS boolean 653 AS 'int8ge' 654 LANGUAGE 'internal' 655 IMMUTABLE STRICT 656 PARALLEL SAFE; 657CREATE FUNCTION isngt(isbn, isbn13) 658 RETURNS boolean 659 AS 'int8gt' 660 LANGUAGE 'internal' 661 IMMUTABLE STRICT 662 PARALLEL SAFE; 663CREATE FUNCTION isnne(isbn, isbn13) 664 RETURNS boolean 665 AS 'int8ne' 666 LANGUAGE 'internal' 667 IMMUTABLE STRICT 668 PARALLEL SAFE; 669 670CREATE FUNCTION isnlt(isbn, ean13) 671 RETURNS boolean 672 AS 'int8lt' 673 LANGUAGE 'internal' 674 IMMUTABLE STRICT 675 PARALLEL SAFE; 676CREATE FUNCTION isnle(isbn, ean13) 677 RETURNS boolean 678 AS 'int8le' 679 LANGUAGE 'internal' 680 IMMUTABLE STRICT 681 PARALLEL SAFE; 682CREATE FUNCTION isneq(isbn, ean13) 683 RETURNS boolean 684 AS 'int8eq' 685 LANGUAGE 'internal' 686 IMMUTABLE STRICT 687 PARALLEL SAFE; 688CREATE FUNCTION isnge(isbn, ean13) 689 RETURNS boolean 690 AS 'int8ge' 691 LANGUAGE 'internal' 692 IMMUTABLE STRICT 693 PARALLEL SAFE; 694CREATE FUNCTION isngt(isbn, ean13) 695 RETURNS boolean 696 AS 'int8gt' 697 LANGUAGE 'internal' 698 IMMUTABLE STRICT 699 PARALLEL SAFE; 700CREATE FUNCTION isnne(isbn, ean13) 701 RETURNS boolean 702 AS 'int8ne' 703 LANGUAGE 'internal' 704 IMMUTABLE STRICT 705 PARALLEL SAFE; 706 707--------------------------------------------------- 708-- ISMN13: 709CREATE FUNCTION isnlt(ismn13, ismn13) 710 RETURNS boolean 711 AS 'int8lt' 712 LANGUAGE 'internal' 713 IMMUTABLE STRICT 714 PARALLEL SAFE; 715CREATE FUNCTION isnle(ismn13, ismn13) 716 RETURNS boolean 717 AS 'int8le' 718 LANGUAGE 'internal' 719 IMMUTABLE STRICT 720 PARALLEL SAFE; 721CREATE FUNCTION isneq(ismn13, ismn13) 722 RETURNS boolean 723 AS 'int8eq' 724 LANGUAGE 'internal' 725 IMMUTABLE STRICT 726 PARALLEL SAFE; 727CREATE FUNCTION isnge(ismn13, ismn13) 728 RETURNS boolean 729 AS 'int8ge' 730 LANGUAGE 'internal' 731 IMMUTABLE STRICT 732 PARALLEL SAFE; 733CREATE FUNCTION isngt(ismn13, ismn13) 734 RETURNS boolean 735 AS 'int8gt' 736 LANGUAGE 'internal' 737 IMMUTABLE STRICT 738 PARALLEL SAFE; 739CREATE FUNCTION isnne(ismn13, ismn13) 740 RETURNS boolean 741 AS 'int8ne' 742 LANGUAGE 'internal' 743 IMMUTABLE STRICT 744 PARALLEL SAFE; 745 746CREATE FUNCTION isnlt(ismn13, ismn) 747 RETURNS boolean 748 AS 'int8lt' 749 LANGUAGE 'internal' 750 IMMUTABLE STRICT 751 PARALLEL SAFE; 752CREATE FUNCTION isnle(ismn13, ismn) 753 RETURNS boolean 754 AS 'int8le' 755 LANGUAGE 'internal' 756 IMMUTABLE STRICT 757 PARALLEL SAFE; 758CREATE FUNCTION isneq(ismn13, ismn) 759 RETURNS boolean 760 AS 'int8eq' 761 LANGUAGE 'internal' 762 IMMUTABLE STRICT 763 PARALLEL SAFE; 764CREATE FUNCTION isnge(ismn13, ismn) 765 RETURNS boolean 766 AS 'int8ge' 767 LANGUAGE 'internal' 768 IMMUTABLE STRICT 769 PARALLEL SAFE; 770CREATE FUNCTION isngt(ismn13, ismn) 771 RETURNS boolean 772 AS 'int8gt' 773 LANGUAGE 'internal' 774 IMMUTABLE STRICT 775 PARALLEL SAFE; 776CREATE FUNCTION isnne(ismn13, ismn) 777 RETURNS boolean 778 AS 'int8ne' 779 LANGUAGE 'internal' 780 IMMUTABLE STRICT 781 PARALLEL SAFE; 782 783CREATE FUNCTION isnlt(ismn13, ean13) 784 RETURNS boolean 785 AS 'int8lt' 786 LANGUAGE 'internal' 787 IMMUTABLE STRICT 788 PARALLEL SAFE; 789CREATE FUNCTION isnle(ismn13, ean13) 790 RETURNS boolean 791 AS 'int8le' 792 LANGUAGE 'internal' 793 IMMUTABLE STRICT 794 PARALLEL SAFE; 795CREATE FUNCTION isneq(ismn13, ean13) 796 RETURNS boolean 797 AS 'int8eq' 798 LANGUAGE 'internal' 799 IMMUTABLE STRICT 800 PARALLEL SAFE; 801CREATE FUNCTION isnge(ismn13, ean13) 802 RETURNS boolean 803 AS 'int8ge' 804 LANGUAGE 'internal' 805 IMMUTABLE STRICT 806 PARALLEL SAFE; 807CREATE FUNCTION isngt(ismn13, ean13) 808 RETURNS boolean 809 AS 'int8gt' 810 LANGUAGE 'internal' 811 IMMUTABLE STRICT 812 PARALLEL SAFE; 813CREATE FUNCTION isnne(ismn13, ean13) 814 RETURNS boolean 815 AS 'int8ne' 816 LANGUAGE 'internal' 817 IMMUTABLE STRICT 818 PARALLEL SAFE; 819 820--------------------------------------------------- 821-- ISMN: 822CREATE FUNCTION isnlt(ismn, ismn) 823 RETURNS boolean 824 AS 'int8lt' 825 LANGUAGE 'internal' 826 IMMUTABLE STRICT 827 PARALLEL SAFE; 828CREATE FUNCTION isnle(ismn, ismn) 829 RETURNS boolean 830 AS 'int8le' 831 LANGUAGE 'internal' 832 IMMUTABLE STRICT 833 PARALLEL SAFE; 834CREATE FUNCTION isneq(ismn, ismn) 835 RETURNS boolean 836 AS 'int8eq' 837 LANGUAGE 'internal' 838 IMMUTABLE STRICT 839 PARALLEL SAFE; 840CREATE FUNCTION isnge(ismn, ismn) 841 RETURNS boolean 842 AS 'int8ge' 843 LANGUAGE 'internal' 844 IMMUTABLE STRICT 845 PARALLEL SAFE; 846CREATE FUNCTION isngt(ismn, ismn) 847 RETURNS boolean 848 AS 'int8gt' 849 LANGUAGE 'internal' 850 IMMUTABLE STRICT 851 PARALLEL SAFE; 852CREATE FUNCTION isnne(ismn, ismn) 853 RETURNS boolean 854 AS 'int8ne' 855 LANGUAGE 'internal' 856 IMMUTABLE STRICT 857 PARALLEL SAFE; 858 859CREATE FUNCTION isnlt(ismn, ismn13) 860 RETURNS boolean 861 AS 'int8lt' 862 LANGUAGE 'internal' 863 IMMUTABLE STRICT 864 PARALLEL SAFE; 865CREATE FUNCTION isnle(ismn, ismn13) 866 RETURNS boolean 867 AS 'int8le' 868 LANGUAGE 'internal' 869 IMMUTABLE STRICT 870 PARALLEL SAFE; 871CREATE FUNCTION isneq(ismn, ismn13) 872 RETURNS boolean 873 AS 'int8eq' 874 LANGUAGE 'internal' 875 IMMUTABLE STRICT 876 PARALLEL SAFE; 877CREATE FUNCTION isnge(ismn, ismn13) 878 RETURNS boolean 879 AS 'int8ge' 880 LANGUAGE 'internal' 881 IMMUTABLE STRICT 882 PARALLEL SAFE; 883CREATE FUNCTION isngt(ismn, ismn13) 884 RETURNS boolean 885 AS 'int8gt' 886 LANGUAGE 'internal' 887 IMMUTABLE STRICT 888 PARALLEL SAFE; 889CREATE FUNCTION isnne(ismn, ismn13) 890 RETURNS boolean 891 AS 'int8ne' 892 LANGUAGE 'internal' 893 IMMUTABLE STRICT 894 PARALLEL SAFE; 895 896CREATE FUNCTION isnlt(ismn, ean13) 897 RETURNS boolean 898 AS 'int8lt' 899 LANGUAGE 'internal' 900 IMMUTABLE STRICT 901 PARALLEL SAFE; 902CREATE FUNCTION isnle(ismn, ean13) 903 RETURNS boolean 904 AS 'int8le' 905 LANGUAGE 'internal' 906 IMMUTABLE STRICT 907 PARALLEL SAFE; 908CREATE FUNCTION isneq(ismn, ean13) 909 RETURNS boolean 910 AS 'int8eq' 911 LANGUAGE 'internal' 912 IMMUTABLE STRICT 913 PARALLEL SAFE; 914CREATE FUNCTION isnge(ismn, ean13) 915 RETURNS boolean 916 AS 'int8ge' 917 LANGUAGE 'internal' 918 IMMUTABLE STRICT 919 PARALLEL SAFE; 920CREATE FUNCTION isngt(ismn, ean13) 921 RETURNS boolean 922 AS 'int8gt' 923 LANGUAGE 'internal' 924 IMMUTABLE STRICT 925 PARALLEL SAFE; 926CREATE FUNCTION isnne(ismn, ean13) 927 RETURNS boolean 928 AS 'int8ne' 929 LANGUAGE 'internal' 930 IMMUTABLE STRICT 931 PARALLEL SAFE; 932 933--------------------------------------------------- 934-- ISSN13: 935CREATE FUNCTION isnlt(issn13, issn13) 936 RETURNS boolean 937 AS 'int8lt' 938 LANGUAGE 'internal' 939 IMMUTABLE STRICT 940 PARALLEL SAFE; 941CREATE FUNCTION isnle(issn13, issn13) 942 RETURNS boolean 943 AS 'int8le' 944 LANGUAGE 'internal' 945 IMMUTABLE STRICT 946 PARALLEL SAFE; 947CREATE FUNCTION isneq(issn13, issn13) 948 RETURNS boolean 949 AS 'int8eq' 950 LANGUAGE 'internal' 951 IMMUTABLE STRICT 952 PARALLEL SAFE; 953CREATE FUNCTION isnge(issn13, issn13) 954 RETURNS boolean 955 AS 'int8ge' 956 LANGUAGE 'internal' 957 IMMUTABLE STRICT 958 PARALLEL SAFE; 959CREATE FUNCTION isngt(issn13, issn13) 960 RETURNS boolean 961 AS 'int8gt' 962 LANGUAGE 'internal' 963 IMMUTABLE STRICT 964 PARALLEL SAFE; 965CREATE FUNCTION isnne(issn13, issn13) 966 RETURNS boolean 967 AS 'int8ne' 968 LANGUAGE 'internal' 969 IMMUTABLE STRICT 970 PARALLEL SAFE; 971 972CREATE FUNCTION isnlt(issn13, issn) 973 RETURNS boolean 974 AS 'int8lt' 975 LANGUAGE 'internal' 976 IMMUTABLE STRICT 977 PARALLEL SAFE; 978CREATE FUNCTION isnle(issn13, issn) 979 RETURNS boolean 980 AS 'int8le' 981 LANGUAGE 'internal' 982 IMMUTABLE STRICT 983 PARALLEL SAFE; 984CREATE FUNCTION isneq(issn13, issn) 985 RETURNS boolean 986 AS 'int8eq' 987 LANGUAGE 'internal' 988 IMMUTABLE STRICT 989 PARALLEL SAFE; 990CREATE FUNCTION isnge(issn13, issn) 991 RETURNS boolean 992 AS 'int8ge' 993 LANGUAGE 'internal' 994 IMMUTABLE STRICT 995 PARALLEL SAFE; 996CREATE FUNCTION isngt(issn13, issn) 997 RETURNS boolean 998 AS 'int8gt' 999 LANGUAGE 'internal' 1000 IMMUTABLE STRICT 1001 PARALLEL SAFE; 1002CREATE FUNCTION isnne(issn13, issn) 1003 RETURNS boolean 1004 AS 'int8ne' 1005 LANGUAGE 'internal' 1006 IMMUTABLE STRICT 1007 PARALLEL SAFE; 1008 1009CREATE FUNCTION isnlt(issn13, ean13) 1010 RETURNS boolean 1011 AS 'int8lt' 1012 LANGUAGE 'internal' 1013 IMMUTABLE STRICT 1014 PARALLEL SAFE; 1015CREATE FUNCTION isnle(issn13, ean13) 1016 RETURNS boolean 1017 AS 'int8le' 1018 LANGUAGE 'internal' 1019 IMMUTABLE STRICT 1020 PARALLEL SAFE; 1021CREATE FUNCTION isneq(issn13, ean13) 1022 RETURNS boolean 1023 AS 'int8eq' 1024 LANGUAGE 'internal' 1025 IMMUTABLE STRICT 1026 PARALLEL SAFE; 1027CREATE FUNCTION isnge(issn13, ean13) 1028 RETURNS boolean 1029 AS 'int8ge' 1030 LANGUAGE 'internal' 1031 IMMUTABLE STRICT 1032 PARALLEL SAFE; 1033CREATE FUNCTION isngt(issn13, ean13) 1034 RETURNS boolean 1035 AS 'int8gt' 1036 LANGUAGE 'internal' 1037 IMMUTABLE STRICT 1038 PARALLEL SAFE; 1039CREATE FUNCTION isnne(issn13, ean13) 1040 RETURNS boolean 1041 AS 'int8ne' 1042 LANGUAGE 'internal' 1043 IMMUTABLE STRICT 1044 PARALLEL SAFE; 1045 1046--------------------------------------------------- 1047-- ISSN: 1048CREATE FUNCTION isnlt(issn, issn) 1049 RETURNS boolean 1050 AS 'int8lt' 1051 LANGUAGE 'internal' 1052 IMMUTABLE STRICT 1053 PARALLEL SAFE; 1054CREATE FUNCTION isnle(issn, issn) 1055 RETURNS boolean 1056 AS 'int8le' 1057 LANGUAGE 'internal' 1058 IMMUTABLE STRICT 1059 PARALLEL SAFE; 1060CREATE FUNCTION isneq(issn, issn) 1061 RETURNS boolean 1062 AS 'int8eq' 1063 LANGUAGE 'internal' 1064 IMMUTABLE STRICT 1065 PARALLEL SAFE; 1066CREATE FUNCTION isnge(issn, issn) 1067 RETURNS boolean 1068 AS 'int8ge' 1069 LANGUAGE 'internal' 1070 IMMUTABLE STRICT 1071 PARALLEL SAFE; 1072CREATE FUNCTION isngt(issn, issn) 1073 RETURNS boolean 1074 AS 'int8gt' 1075 LANGUAGE 'internal' 1076 IMMUTABLE STRICT 1077 PARALLEL SAFE; 1078CREATE FUNCTION isnne(issn, issn) 1079 RETURNS boolean 1080 AS 'int8ne' 1081 LANGUAGE 'internal' 1082 IMMUTABLE STRICT 1083 PARALLEL SAFE; 1084 1085CREATE FUNCTION isnlt(issn, issn13) 1086 RETURNS boolean 1087 AS 'int8lt' 1088 LANGUAGE 'internal' 1089 IMMUTABLE STRICT 1090 PARALLEL SAFE; 1091CREATE FUNCTION isnle(issn, issn13) 1092 RETURNS boolean 1093 AS 'int8le' 1094 LANGUAGE 'internal' 1095 IMMUTABLE STRICT 1096 PARALLEL SAFE; 1097CREATE FUNCTION isneq(issn, issn13) 1098 RETURNS boolean 1099 AS 'int8eq' 1100 LANGUAGE 'internal' 1101 IMMUTABLE STRICT 1102 PARALLEL SAFE; 1103CREATE FUNCTION isnge(issn, issn13) 1104 RETURNS boolean 1105 AS 'int8ge' 1106 LANGUAGE 'internal' 1107 IMMUTABLE STRICT 1108 PARALLEL SAFE; 1109CREATE FUNCTION isngt(issn, issn13) 1110 RETURNS boolean 1111 AS 'int8gt' 1112 LANGUAGE 'internal' 1113 IMMUTABLE STRICT 1114 PARALLEL SAFE; 1115CREATE FUNCTION isnne(issn, issn13) 1116 RETURNS boolean 1117 AS 'int8ne' 1118 LANGUAGE 'internal' 1119 IMMUTABLE STRICT 1120 PARALLEL SAFE; 1121 1122CREATE FUNCTION isnlt(issn, ean13) 1123 RETURNS boolean 1124 AS 'int8lt' 1125 LANGUAGE 'internal' 1126 IMMUTABLE STRICT 1127 PARALLEL SAFE; 1128CREATE FUNCTION isnle(issn, ean13) 1129 RETURNS boolean 1130 AS 'int8le' 1131 LANGUAGE 'internal' 1132 IMMUTABLE STRICT 1133 PARALLEL SAFE; 1134CREATE FUNCTION isneq(issn, ean13) 1135 RETURNS boolean 1136 AS 'int8eq' 1137 LANGUAGE 'internal' 1138 IMMUTABLE STRICT 1139 PARALLEL SAFE; 1140CREATE FUNCTION isnge(issn, ean13) 1141 RETURNS boolean 1142 AS 'int8ge' 1143 LANGUAGE 'internal' 1144 IMMUTABLE STRICT 1145 PARALLEL SAFE; 1146CREATE FUNCTION isngt(issn, ean13) 1147 RETURNS boolean 1148 AS 'int8gt' 1149 LANGUAGE 'internal' 1150 IMMUTABLE STRICT 1151 PARALLEL SAFE; 1152CREATE FUNCTION isnne(issn, ean13) 1153 RETURNS boolean 1154 AS 'int8ne' 1155 LANGUAGE 'internal' 1156 IMMUTABLE STRICT 1157 PARALLEL SAFE; 1158 1159--------------------------------------------------- 1160-- UPC: 1161CREATE FUNCTION isnlt(upc, upc) 1162 RETURNS boolean 1163 AS 'int8lt' 1164 LANGUAGE 'internal' 1165 IMMUTABLE STRICT 1166 PARALLEL SAFE; 1167CREATE FUNCTION isnle(upc, upc) 1168 RETURNS boolean 1169 AS 'int8le' 1170 LANGUAGE 'internal' 1171 IMMUTABLE STRICT 1172 PARALLEL SAFE; 1173CREATE FUNCTION isneq(upc, upc) 1174 RETURNS boolean 1175 AS 'int8eq' 1176 LANGUAGE 'internal' 1177 IMMUTABLE STRICT 1178 PARALLEL SAFE; 1179CREATE FUNCTION isnge(upc, upc) 1180 RETURNS boolean 1181 AS 'int8ge' 1182 LANGUAGE 'internal' 1183 IMMUTABLE STRICT 1184 PARALLEL SAFE; 1185CREATE FUNCTION isngt(upc, upc) 1186 RETURNS boolean 1187 AS 'int8gt' 1188 LANGUAGE 'internal' 1189 IMMUTABLE STRICT 1190 PARALLEL SAFE; 1191CREATE FUNCTION isnne(upc, upc) 1192 RETURNS boolean 1193 AS 'int8ne' 1194 LANGUAGE 'internal' 1195 IMMUTABLE STRICT 1196 PARALLEL SAFE; 1197 1198CREATE FUNCTION isnlt(upc, ean13) 1199 RETURNS boolean 1200 AS 'int8lt' 1201 LANGUAGE 'internal' 1202 IMMUTABLE STRICT 1203 PARALLEL SAFE; 1204CREATE FUNCTION isnle(upc, ean13) 1205 RETURNS boolean 1206 AS 'int8le' 1207 LANGUAGE 'internal' 1208 IMMUTABLE STRICT 1209 PARALLEL SAFE; 1210CREATE FUNCTION isneq(upc, ean13) 1211 RETURNS boolean 1212 AS 'int8eq' 1213 LANGUAGE 'internal' 1214 IMMUTABLE STRICT 1215 PARALLEL SAFE; 1216CREATE FUNCTION isnge(upc, ean13) 1217 RETURNS boolean 1218 AS 'int8ge' 1219 LANGUAGE 'internal' 1220 IMMUTABLE STRICT 1221 PARALLEL SAFE; 1222CREATE FUNCTION isngt(upc, ean13) 1223 RETURNS boolean 1224 AS 'int8gt' 1225 LANGUAGE 'internal' 1226 IMMUTABLE STRICT 1227 PARALLEL SAFE; 1228CREATE FUNCTION isnne(upc, ean13) 1229 RETURNS boolean 1230 AS 'int8ne' 1231 LANGUAGE 'internal' 1232 IMMUTABLE STRICT 1233 PARALLEL SAFE; 1234 1235-- 1236-- Now the operators: 1237-- 1238 1239-- 1240-- EAN13 operators: 1241-- 1242--------------------------------------------------- 1243CREATE OPERATOR < ( 1244 PROCEDURE = isnlt, 1245 LEFTARG = ean13, 1246 RIGHTARG = ean13, 1247 COMMUTATOR = >, 1248 NEGATOR = >=, 1249 RESTRICT = scalarltsel, 1250 JOIN = scalarltjoinsel); 1251CREATE OPERATOR <= ( 1252 PROCEDURE = isnle, 1253 LEFTARG = ean13, 1254 RIGHTARG = ean13, 1255 COMMUTATOR = >=, 1256 NEGATOR = >, 1257 RESTRICT = scalarltsel, 1258 JOIN = scalarltjoinsel); 1259CREATE OPERATOR = ( 1260 PROCEDURE = isneq, 1261 LEFTARG = ean13, 1262 RIGHTARG = ean13, 1263 COMMUTATOR = =, 1264 NEGATOR = <>, 1265 RESTRICT = eqsel, 1266 JOIN = eqjoinsel, 1267 MERGES, 1268 HASHES); 1269CREATE OPERATOR >= ( 1270 PROCEDURE = isnge, 1271 LEFTARG = ean13, 1272 RIGHTARG = ean13, 1273 COMMUTATOR = <=, 1274 NEGATOR = <, 1275 RESTRICT = scalargtsel, 1276 JOIN = scalargtjoinsel ); 1277CREATE OPERATOR > ( 1278 PROCEDURE = isngt, 1279 LEFTARG = ean13, 1280 RIGHTARG = ean13, 1281 COMMUTATOR = <, 1282 NEGATOR = <=, 1283 RESTRICT = scalargtsel, 1284 JOIN = scalargtjoinsel ); 1285CREATE OPERATOR <> ( 1286 PROCEDURE = isnne, 1287 LEFTARG = ean13, 1288 RIGHTARG = ean13, 1289 COMMUTATOR = <>, 1290 NEGATOR = =, 1291 RESTRICT = neqsel, 1292 JOIN = neqjoinsel); 1293 1294CREATE OPERATOR < ( 1295 PROCEDURE = isnlt, 1296 LEFTARG = ean13, 1297 RIGHTARG = isbn13, 1298 COMMUTATOR = >, 1299 NEGATOR = >=, 1300 RESTRICT = scalarltsel, 1301 JOIN = scalarltjoinsel); 1302CREATE OPERATOR <= ( 1303 PROCEDURE = isnle, 1304 LEFTARG = ean13, 1305 RIGHTARG = isbn13, 1306 COMMUTATOR = >=, 1307 NEGATOR = >, 1308 RESTRICT = scalarltsel, 1309 JOIN = scalarltjoinsel); 1310CREATE OPERATOR = ( 1311 PROCEDURE = isneq, 1312 LEFTARG = ean13, 1313 RIGHTARG = isbn13, 1314 COMMUTATOR = =, 1315 NEGATOR = <>, 1316 RESTRICT = eqsel, 1317 JOIN = eqjoinsel, 1318 MERGES, 1319 HASHES); 1320CREATE OPERATOR >= ( 1321 PROCEDURE = isnge, 1322 LEFTARG = ean13, 1323 RIGHTARG = isbn13, 1324 COMMUTATOR = <=, 1325 NEGATOR = <, 1326 RESTRICT = scalargtsel, 1327 JOIN = scalargtjoinsel ); 1328CREATE OPERATOR > ( 1329 PROCEDURE = isngt, 1330 LEFTARG = ean13, 1331 RIGHTARG = isbn13, 1332 COMMUTATOR = <, 1333 NEGATOR = <=, 1334 RESTRICT = scalargtsel, 1335 JOIN = scalargtjoinsel ); 1336CREATE OPERATOR <> ( 1337 PROCEDURE = isnne, 1338 LEFTARG = ean13, 1339 RIGHTARG = isbn13, 1340 COMMUTATOR = <>, 1341 NEGATOR = =, 1342 RESTRICT = neqsel, 1343 JOIN = neqjoinsel); 1344 1345CREATE OPERATOR < ( 1346 PROCEDURE = isnlt, 1347 LEFTARG = isbn13, 1348 RIGHTARG = ean13, 1349 COMMUTATOR = >, 1350 NEGATOR = >=, 1351 RESTRICT = scalarltsel, 1352 JOIN = scalarltjoinsel); 1353CREATE OPERATOR <= ( 1354 PROCEDURE = isnle, 1355 LEFTARG = isbn13, 1356 RIGHTARG = ean13, 1357 COMMUTATOR = >=, 1358 NEGATOR = >, 1359 RESTRICT = scalarltsel, 1360 JOIN = scalarltjoinsel); 1361CREATE OPERATOR = ( 1362 PROCEDURE = isneq, 1363 LEFTARG = isbn13, 1364 RIGHTARG = ean13, 1365 COMMUTATOR = =, 1366 NEGATOR = <>, 1367 RESTRICT = eqsel, 1368 JOIN = eqjoinsel, 1369 MERGES, 1370 HASHES); 1371CREATE OPERATOR >= ( 1372 PROCEDURE = isnge, 1373 LEFTARG = isbn13, 1374 RIGHTARG = ean13, 1375 COMMUTATOR = <=, 1376 NEGATOR = <, 1377 RESTRICT = scalargtsel, 1378 JOIN = scalargtjoinsel ); 1379CREATE OPERATOR > ( 1380 PROCEDURE = isngt, 1381 LEFTARG = isbn13, 1382 RIGHTARG = ean13, 1383 COMMUTATOR = <, 1384 NEGATOR = <=, 1385 RESTRICT = scalargtsel, 1386 JOIN = scalargtjoinsel ); 1387CREATE OPERATOR <> ( 1388 PROCEDURE = isnne, 1389 LEFTARG = isbn13, 1390 RIGHTARG = ean13, 1391 COMMUTATOR = <>, 1392 NEGATOR = =, 1393 RESTRICT = neqsel, 1394 JOIN = neqjoinsel); 1395 1396CREATE OPERATOR < ( 1397 PROCEDURE = isnlt, 1398 LEFTARG = ean13, 1399 RIGHTARG = ismn13, 1400 COMMUTATOR = >, 1401 NEGATOR = >=, 1402 RESTRICT = scalarltsel, 1403 JOIN = scalarltjoinsel); 1404CREATE OPERATOR <= ( 1405 PROCEDURE = isnle, 1406 LEFTARG = ean13, 1407 RIGHTARG = ismn13, 1408 COMMUTATOR = >=, 1409 NEGATOR = >, 1410 RESTRICT = scalarltsel, 1411 JOIN = scalarltjoinsel); 1412CREATE OPERATOR = ( 1413 PROCEDURE = isneq, 1414 LEFTARG = ean13, 1415 RIGHTARG = ismn13, 1416 COMMUTATOR = =, 1417 NEGATOR = <>, 1418 RESTRICT = eqsel, 1419 JOIN = eqjoinsel, 1420 MERGES, 1421 HASHES); 1422CREATE OPERATOR >= ( 1423 PROCEDURE = isnge, 1424 LEFTARG = ean13, 1425 RIGHTARG = ismn13, 1426 COMMUTATOR = <=, 1427 NEGATOR = <, 1428 RESTRICT = scalargtsel, 1429 JOIN = scalargtjoinsel); 1430CREATE OPERATOR > ( 1431 PROCEDURE = isngt, 1432 LEFTARG = ean13, 1433 RIGHTARG = ismn13, 1434 COMMUTATOR = <, 1435 NEGATOR = <=, 1436 RESTRICT = scalargtsel, 1437 JOIN = scalargtjoinsel); 1438CREATE OPERATOR <> ( 1439 PROCEDURE = isnne, 1440 LEFTARG = ean13, 1441 RIGHTARG = ismn13, 1442 COMMUTATOR = <>, 1443 NEGATOR = =, 1444 RESTRICT = neqsel, 1445 JOIN = neqjoinsel); 1446 1447CREATE OPERATOR < ( 1448 PROCEDURE = isnlt, 1449 LEFTARG = ismn13, 1450 RIGHTARG = ean13, 1451 COMMUTATOR = >, 1452 NEGATOR = >=, 1453 RESTRICT = scalarltsel, 1454 JOIN = scalarltjoinsel); 1455CREATE OPERATOR <= ( 1456 PROCEDURE = isnle, 1457 LEFTARG = ismn13, 1458 RIGHTARG = ean13, 1459 COMMUTATOR = >=, 1460 NEGATOR = >, 1461 RESTRICT = scalarltsel, 1462 JOIN = scalarltjoinsel); 1463CREATE OPERATOR = ( 1464 PROCEDURE = isneq, 1465 LEFTARG = ismn13, 1466 RIGHTARG = ean13, 1467 COMMUTATOR = =, 1468 NEGATOR = <>, 1469 RESTRICT = eqsel, 1470 JOIN = eqjoinsel, 1471 MERGES, 1472 HASHES); 1473CREATE OPERATOR >= ( 1474 PROCEDURE = isnge, 1475 LEFTARG = ismn13, 1476 RIGHTARG = ean13, 1477 COMMUTATOR = <=, 1478 NEGATOR = <, 1479 RESTRICT = scalargtsel, 1480 JOIN = scalargtjoinsel ); 1481CREATE OPERATOR > ( 1482 PROCEDURE = isngt, 1483 LEFTARG = ismn13, 1484 RIGHTARG = ean13, 1485 COMMUTATOR = <, 1486 NEGATOR = <=, 1487 RESTRICT = scalargtsel, 1488 JOIN = scalargtjoinsel ); 1489CREATE OPERATOR <> ( 1490 PROCEDURE = isnne, 1491 LEFTARG = ismn13, 1492 RIGHTARG = ean13, 1493 COMMUTATOR = <>, 1494 NEGATOR = =, 1495 RESTRICT = neqsel, 1496 JOIN = neqjoinsel); 1497 1498CREATE OPERATOR < ( 1499 PROCEDURE = isnlt, 1500 LEFTARG = ean13, 1501 RIGHTARG = issn13, 1502 COMMUTATOR = >, 1503 NEGATOR = >=, 1504 RESTRICT = scalarltsel, 1505 JOIN = scalarltjoinsel); 1506CREATE OPERATOR <= ( 1507 PROCEDURE = isnle, 1508 LEFTARG = ean13, 1509 RIGHTARG = issn13, 1510 COMMUTATOR = >=, 1511 NEGATOR = >, 1512 RESTRICT = scalarltsel, 1513 JOIN = scalarltjoinsel); 1514CREATE OPERATOR = ( 1515 PROCEDURE = isneq, 1516 LEFTARG = ean13, 1517 RIGHTARG = issn13, 1518 COMMUTATOR = =, 1519 NEGATOR = <>, 1520 RESTRICT = eqsel, 1521 JOIN = eqjoinsel, 1522 MERGES, 1523 HASHES); 1524CREATE OPERATOR >= ( 1525 PROCEDURE = isnge, 1526 LEFTARG = ean13, 1527 RIGHTARG = issn13, 1528 COMMUTATOR = <=, 1529 NEGATOR = <, 1530 RESTRICT = scalargtsel, 1531 JOIN = scalargtjoinsel); 1532CREATE OPERATOR > ( 1533 PROCEDURE = isngt, 1534 LEFTARG = ean13, 1535 RIGHTARG = issn13, 1536 COMMUTATOR = <, 1537 NEGATOR = <=, 1538 RESTRICT = scalargtsel, 1539 JOIN = scalargtjoinsel); 1540CREATE OPERATOR <> ( 1541 PROCEDURE = isnne, 1542 LEFTARG = ean13, 1543 RIGHTARG = issn13, 1544 COMMUTATOR = <>, 1545 NEGATOR = =, 1546 RESTRICT = neqsel, 1547 JOIN = neqjoinsel); 1548 1549CREATE OPERATOR < ( 1550 PROCEDURE = isnlt, 1551 LEFTARG = ean13, 1552 RIGHTARG = isbn, 1553 COMMUTATOR = >, 1554 NEGATOR = >=, 1555 RESTRICT = scalarltsel, 1556 JOIN = scalarltjoinsel); 1557CREATE OPERATOR <= ( 1558 PROCEDURE = isnle, 1559 LEFTARG = ean13, 1560 RIGHTARG = isbn, 1561 COMMUTATOR = >=, 1562 NEGATOR = >, 1563 RESTRICT = scalarltsel, 1564 JOIN = scalarltjoinsel); 1565CREATE OPERATOR = ( 1566 PROCEDURE = isneq, 1567 LEFTARG = ean13, 1568 RIGHTARG = isbn, 1569 COMMUTATOR = =, 1570 NEGATOR = <>, 1571 RESTRICT = eqsel, 1572 JOIN = eqjoinsel, 1573 MERGES, 1574 HASHES); 1575CREATE OPERATOR >= ( 1576 PROCEDURE = isnge, 1577 LEFTARG = ean13, 1578 RIGHTARG = isbn, 1579 COMMUTATOR = <=, 1580 NEGATOR = <, 1581 RESTRICT = scalargtsel, 1582 JOIN = scalargtjoinsel); 1583CREATE OPERATOR > ( 1584 PROCEDURE = isngt, 1585 LEFTARG = ean13, 1586 RIGHTARG = isbn, 1587 COMMUTATOR = <, 1588 NEGATOR = <=, 1589 RESTRICT = scalargtsel, 1590 JOIN = scalargtjoinsel); 1591CREATE OPERATOR <> ( 1592 PROCEDURE = isnne, 1593 LEFTARG = ean13, 1594 RIGHTARG = isbn, 1595 COMMUTATOR = <>, 1596 NEGATOR = =, 1597 RESTRICT = neqsel, 1598 JOIN = neqjoinsel); 1599 1600CREATE OPERATOR < ( 1601 PROCEDURE = isnlt, 1602 LEFTARG = ean13, 1603 RIGHTARG = ismn, 1604 COMMUTATOR = >, 1605 NEGATOR = >=, 1606 RESTRICT = scalarltsel, 1607 JOIN = scalarltjoinsel); 1608CREATE OPERATOR <= ( 1609 PROCEDURE = isnle, 1610 LEFTARG = ean13, 1611 RIGHTARG = ismn, 1612 COMMUTATOR = >=, 1613 NEGATOR = >, 1614 RESTRICT = scalarltsel, 1615 JOIN = scalarltjoinsel); 1616CREATE OPERATOR = ( 1617 PROCEDURE = isneq, 1618 LEFTARG = ean13, 1619 RIGHTARG = ismn, 1620 COMMUTATOR = =, 1621 NEGATOR = <>, 1622 RESTRICT = eqsel, 1623 JOIN = eqjoinsel, 1624 MERGES, 1625 HASHES); 1626CREATE OPERATOR >= ( 1627 PROCEDURE = isnge, 1628 LEFTARG = ean13, 1629 RIGHTARG = ismn, 1630 COMMUTATOR = <=, 1631 NEGATOR = <, 1632 RESTRICT = scalargtsel, 1633 JOIN = scalargtjoinsel); 1634CREATE OPERATOR > ( 1635 PROCEDURE = isngt, 1636 LEFTARG = ean13, 1637 RIGHTARG = ismn, 1638 COMMUTATOR = <, 1639 NEGATOR = <=, 1640 RESTRICT = scalargtsel, 1641 JOIN = scalargtjoinsel); 1642CREATE OPERATOR <> ( 1643 PROCEDURE = isnne, 1644 LEFTARG = ean13, 1645 RIGHTARG = ismn, 1646 COMMUTATOR = <>, 1647 NEGATOR = =, 1648 RESTRICT = neqsel, 1649 JOIN = neqjoinsel); 1650 1651CREATE OPERATOR < ( 1652 PROCEDURE = isnlt, 1653 LEFTARG = ean13, 1654 RIGHTARG = issn, 1655 COMMUTATOR = >, 1656 NEGATOR = >=, 1657 RESTRICT = scalarltsel, 1658 JOIN = scalarltjoinsel); 1659CREATE OPERATOR <= ( 1660 PROCEDURE = isnle, 1661 LEFTARG = ean13, 1662 RIGHTARG = issn, 1663 COMMUTATOR = >=, 1664 NEGATOR = >, 1665 RESTRICT = scalarltsel, 1666 JOIN = scalarltjoinsel); 1667CREATE OPERATOR = ( 1668 PROCEDURE = isneq, 1669 LEFTARG = ean13, 1670 RIGHTARG = issn, 1671 COMMUTATOR = =, 1672 NEGATOR = <>, 1673 RESTRICT = eqsel, 1674 JOIN = eqjoinsel, 1675 MERGES, 1676 HASHES); 1677CREATE OPERATOR >= ( 1678 PROCEDURE = isnge, 1679 LEFTARG = ean13, 1680 RIGHTARG = issn, 1681 COMMUTATOR = <=, 1682 NEGATOR = <, 1683 RESTRICT = scalargtsel, 1684 JOIN = scalargtjoinsel); 1685CREATE OPERATOR > ( 1686 PROCEDURE = isngt, 1687 LEFTARG = ean13, 1688 RIGHTARG = issn, 1689 COMMUTATOR = <, 1690 NEGATOR = <=, 1691 RESTRICT = scalargtsel, 1692 JOIN = scalargtjoinsel); 1693CREATE OPERATOR <> ( 1694 PROCEDURE = isnne, 1695 LEFTARG = ean13, 1696 RIGHTARG = issn, 1697 COMMUTATOR = <>, 1698 NEGATOR = =, 1699 RESTRICT = neqsel, 1700 JOIN = neqjoinsel); 1701 1702CREATE OPERATOR < ( 1703 PROCEDURE = isnlt, 1704 LEFTARG = ean13, 1705 RIGHTARG = upc, 1706 COMMUTATOR = >, 1707 NEGATOR = >=, 1708 RESTRICT = scalarltsel, 1709 JOIN = scalarltjoinsel); 1710CREATE OPERATOR <= ( 1711 PROCEDURE = isnle, 1712 LEFTARG = ean13, 1713 RIGHTARG = upc, 1714 COMMUTATOR = >=, 1715 NEGATOR = >, 1716 RESTRICT = scalarltsel, 1717 JOIN = scalarltjoinsel); 1718CREATE OPERATOR = ( 1719 PROCEDURE = isneq, 1720 LEFTARG = ean13, 1721 RIGHTARG = upc, 1722 COMMUTATOR = =, 1723 NEGATOR = <>, 1724 RESTRICT = eqsel, 1725 JOIN = eqjoinsel, 1726 MERGES, 1727 HASHES); 1728CREATE OPERATOR >= ( 1729 PROCEDURE = isnge, 1730 LEFTARG = ean13, 1731 RIGHTARG = upc, 1732 COMMUTATOR = <=, 1733 NEGATOR = <, 1734 RESTRICT = scalargtsel, 1735 JOIN = scalargtjoinsel); 1736CREATE OPERATOR > ( 1737 PROCEDURE = isngt, 1738 LEFTARG = ean13, 1739 RIGHTARG = upc, 1740 COMMUTATOR = <, 1741 NEGATOR = <=, 1742 RESTRICT = scalargtsel, 1743 JOIN = scalargtjoinsel); 1744CREATE OPERATOR <> ( 1745 PROCEDURE = isnne, 1746 LEFTARG = ean13, 1747 RIGHTARG = upc, 1748 COMMUTATOR = <>, 1749 NEGATOR = =, 1750 RESTRICT = neqsel, 1751 JOIN = neqjoinsel); 1752 1753-- 1754-- ISBN13 operators: 1755-- 1756--------------------------------------------------- 1757CREATE OPERATOR < ( 1758 PROCEDURE = isnlt, 1759 LEFTARG = isbn13, 1760 RIGHTARG = isbn13, 1761 COMMUTATOR = >, 1762 NEGATOR = >=, 1763 RESTRICT = scalarltsel, 1764 JOIN = scalarltjoinsel); 1765CREATE OPERATOR <= ( 1766 PROCEDURE = isnle, 1767 LEFTARG = isbn13, 1768 RIGHTARG = isbn13, 1769 COMMUTATOR = >=, 1770 NEGATOR = >, 1771 RESTRICT = scalarltsel, 1772 JOIN = scalarltjoinsel); 1773CREATE OPERATOR = ( 1774 PROCEDURE = isneq, 1775 LEFTARG = isbn13, 1776 RIGHTARG = isbn13, 1777 COMMUTATOR = =, 1778 NEGATOR = <>, 1779 RESTRICT = eqsel, 1780 JOIN = eqjoinsel, 1781 MERGES, 1782 HASHES); 1783CREATE OPERATOR >= ( 1784 PROCEDURE = isnge, 1785 LEFTARG = isbn13, 1786 RIGHTARG = isbn13, 1787 COMMUTATOR = <=, 1788 NEGATOR = <, 1789 RESTRICT = scalargtsel, 1790 JOIN = scalargtjoinsel ); 1791CREATE OPERATOR > ( 1792 PROCEDURE = isngt, 1793 LEFTARG = isbn13, 1794 RIGHTARG = isbn13, 1795 COMMUTATOR = <, 1796 NEGATOR = <=, 1797 RESTRICT = scalargtsel, 1798 JOIN = scalargtjoinsel ); 1799CREATE OPERATOR <> ( 1800 PROCEDURE = isnne, 1801 LEFTARG = isbn13, 1802 RIGHTARG = isbn13, 1803 COMMUTATOR = <>, 1804 NEGATOR = =, 1805 RESTRICT = neqsel, 1806 JOIN = neqjoinsel); 1807 1808CREATE OPERATOR < ( 1809 PROCEDURE = isnlt, 1810 LEFTARG = isbn13, 1811 RIGHTARG = isbn, 1812 COMMUTATOR = >, 1813 NEGATOR = >=, 1814 RESTRICT = scalarltsel, 1815 JOIN = scalarltjoinsel); 1816CREATE OPERATOR <= ( 1817 PROCEDURE = isnle, 1818 LEFTARG = isbn13, 1819 RIGHTARG = isbn, 1820 COMMUTATOR = >=, 1821 NEGATOR = >, 1822 RESTRICT = scalarltsel, 1823 JOIN = scalarltjoinsel); 1824CREATE OPERATOR = ( 1825 PROCEDURE = isneq, 1826 LEFTARG = isbn13, 1827 RIGHTARG = isbn, 1828 COMMUTATOR = =, 1829 NEGATOR = <>, 1830 RESTRICT = eqsel, 1831 JOIN = eqjoinsel, 1832 MERGES, 1833 HASHES); 1834CREATE OPERATOR >= ( 1835 PROCEDURE = isnge, 1836 LEFTARG = isbn13, 1837 RIGHTARG = isbn, 1838 COMMUTATOR = <=, 1839 NEGATOR = <, 1840 RESTRICT = scalargtsel, 1841 JOIN = scalargtjoinsel ); 1842CREATE OPERATOR > ( 1843 PROCEDURE = isngt, 1844 LEFTARG = isbn13, 1845 RIGHTARG = isbn, 1846 COMMUTATOR = <, 1847 NEGATOR = <=, 1848 RESTRICT = scalargtsel, 1849 JOIN = scalargtjoinsel ); 1850CREATE OPERATOR <> ( 1851 PROCEDURE = isnne, 1852 LEFTARG = isbn13, 1853 RIGHTARG = isbn, 1854 COMMUTATOR = <>, 1855 NEGATOR = =, 1856 RESTRICT = neqsel, 1857 JOIN = neqjoinsel); 1858 1859-- 1860-- ISBN operators: 1861-- 1862--------------------------------------------------- 1863CREATE OPERATOR < ( 1864 PROCEDURE = isnlt, 1865 LEFTARG = isbn, 1866 RIGHTARG = isbn, 1867 COMMUTATOR = >, 1868 NEGATOR = >=, 1869 RESTRICT = scalarltsel, 1870 JOIN = scalarltjoinsel); 1871CREATE OPERATOR <= ( 1872 PROCEDURE = isnle, 1873 LEFTARG = isbn, 1874 RIGHTARG = isbn, 1875 COMMUTATOR = >=, 1876 NEGATOR = >, 1877 RESTRICT = scalarltsel, 1878 JOIN = scalarltjoinsel); 1879CREATE OPERATOR = ( 1880 PROCEDURE = isneq, 1881 LEFTARG = isbn, 1882 RIGHTARG = isbn, 1883 COMMUTATOR = =, 1884 NEGATOR = <>, 1885 RESTRICT = eqsel, 1886 JOIN = eqjoinsel, 1887 MERGES, 1888 HASHES); 1889CREATE OPERATOR >= ( 1890 PROCEDURE = isnge, 1891 LEFTARG = isbn, 1892 RIGHTARG = isbn, 1893 COMMUTATOR = <=, 1894 NEGATOR = <, 1895 RESTRICT = scalargtsel, 1896 JOIN = scalargtjoinsel ); 1897CREATE OPERATOR > ( 1898 PROCEDURE = isngt, 1899 LEFTARG = isbn, 1900 RIGHTARG = isbn, 1901 COMMUTATOR = <, 1902 NEGATOR = <=, 1903 RESTRICT = scalargtsel, 1904 JOIN = scalargtjoinsel ); 1905CREATE OPERATOR <> ( 1906 PROCEDURE = isnne, 1907 LEFTARG = isbn, 1908 RIGHTARG = isbn, 1909 COMMUTATOR = <>, 1910 NEGATOR = =, 1911 RESTRICT = neqsel, 1912 JOIN = neqjoinsel); 1913 1914CREATE OPERATOR < ( 1915 PROCEDURE = isnlt, 1916 LEFTARG = isbn, 1917 RIGHTARG = isbn13, 1918 COMMUTATOR = >, 1919 NEGATOR = >=, 1920 RESTRICT = scalarltsel, 1921 JOIN = scalarltjoinsel); 1922CREATE OPERATOR <= ( 1923 PROCEDURE = isnle, 1924 LEFTARG = isbn, 1925 RIGHTARG = isbn13, 1926 COMMUTATOR = >=, 1927 NEGATOR = >, 1928 RESTRICT = scalarltsel, 1929 JOIN = scalarltjoinsel); 1930CREATE OPERATOR = ( 1931 PROCEDURE = isneq, 1932 LEFTARG = isbn, 1933 RIGHTARG = isbn13, 1934 COMMUTATOR = =, 1935 NEGATOR = <>, 1936 RESTRICT = eqsel, 1937 JOIN = eqjoinsel, 1938 MERGES, 1939 HASHES); 1940CREATE OPERATOR >= ( 1941 PROCEDURE = isnge, 1942 LEFTARG = isbn, 1943 RIGHTARG = isbn13, 1944 COMMUTATOR = <=, 1945 NEGATOR = <, 1946 RESTRICT = scalargtsel, 1947 JOIN = scalargtjoinsel ); 1948CREATE OPERATOR > ( 1949 PROCEDURE = isngt, 1950 LEFTARG = isbn, 1951 RIGHTARG = isbn13, 1952 COMMUTATOR = <, 1953 NEGATOR = <=, 1954 RESTRICT = scalargtsel, 1955 JOIN = scalargtjoinsel ); 1956CREATE OPERATOR <> ( 1957 PROCEDURE = isnne, 1958 LEFTARG = isbn, 1959 RIGHTARG = isbn13, 1960 COMMUTATOR = <>, 1961 NEGATOR = =, 1962 RESTRICT = neqsel, 1963 JOIN = neqjoinsel); 1964 1965CREATE OPERATOR < ( 1966 PROCEDURE = isnlt, 1967 LEFTARG = isbn, 1968 RIGHTARG = ean13, 1969 COMMUTATOR = >, 1970 NEGATOR = >=, 1971 RESTRICT = scalarltsel, 1972 JOIN = scalarltjoinsel); 1973CREATE OPERATOR <= ( 1974 PROCEDURE = isnle, 1975 LEFTARG = isbn, 1976 RIGHTARG = ean13, 1977 COMMUTATOR = >=, 1978 NEGATOR = >, 1979 RESTRICT = scalarltsel, 1980 JOIN = scalarltjoinsel); 1981CREATE OPERATOR = ( 1982 PROCEDURE = isneq, 1983 LEFTARG = isbn, 1984 RIGHTARG = ean13, 1985 COMMUTATOR = =, 1986 NEGATOR = <>, 1987 RESTRICT = eqsel, 1988 JOIN = eqjoinsel, 1989 MERGES, 1990 HASHES); 1991CREATE OPERATOR >= ( 1992 PROCEDURE = isnge, 1993 LEFTARG = isbn, 1994 RIGHTARG = ean13, 1995 COMMUTATOR = <=, 1996 NEGATOR = <, 1997 RESTRICT = scalargtsel, 1998 JOIN = scalargtjoinsel ); 1999CREATE OPERATOR > ( 2000 PROCEDURE = isngt, 2001 LEFTARG = isbn, 2002 RIGHTARG = ean13, 2003 COMMUTATOR = <, 2004 NEGATOR = <=, 2005 RESTRICT = scalargtsel, 2006 JOIN = scalargtjoinsel ); 2007CREATE OPERATOR <> ( 2008 PROCEDURE = isnne, 2009 LEFTARG = isbn, 2010 RIGHTARG = ean13, 2011 COMMUTATOR = <>, 2012 NEGATOR = =, 2013 RESTRICT = neqsel, 2014 JOIN = neqjoinsel); 2015 2016-- 2017-- ISMN13 operators: 2018-- 2019--------------------------------------------------- 2020CREATE OPERATOR < ( 2021 PROCEDURE = isnlt, 2022 LEFTARG = ismn13, 2023 RIGHTARG = ismn13, 2024 COMMUTATOR = >, 2025 NEGATOR = >=, 2026 RESTRICT = scalarltsel, 2027 JOIN = scalarltjoinsel); 2028CREATE OPERATOR <= ( 2029 PROCEDURE = isnle, 2030 LEFTARG = ismn13, 2031 RIGHTARG = ismn13, 2032 COMMUTATOR = >=, 2033 NEGATOR = >, 2034 RESTRICT = scalarltsel, 2035 JOIN = scalarltjoinsel); 2036CREATE OPERATOR = ( 2037 PROCEDURE = isneq, 2038 LEFTARG = ismn13, 2039 RIGHTARG = ismn13, 2040 COMMUTATOR = =, 2041 NEGATOR = <>, 2042 RESTRICT = eqsel, 2043 JOIN = eqjoinsel, 2044 MERGES, 2045 HASHES); 2046CREATE OPERATOR >= ( 2047 PROCEDURE = isnge, 2048 LEFTARG = ismn13, 2049 RIGHTARG = ismn13, 2050 COMMUTATOR = <=, 2051 NEGATOR = <, 2052 RESTRICT = scalargtsel, 2053 JOIN = scalargtjoinsel ); 2054CREATE OPERATOR > ( 2055 PROCEDURE = isngt, 2056 LEFTARG = ismn13, 2057 RIGHTARG = ismn13, 2058 COMMUTATOR = <, 2059 NEGATOR = <=, 2060 RESTRICT = scalargtsel, 2061 JOIN = scalargtjoinsel ); 2062CREATE OPERATOR <> ( 2063 PROCEDURE = isnne, 2064 LEFTARG = ismn13, 2065 RIGHTARG = ismn13, 2066 COMMUTATOR = <>, 2067 NEGATOR = =, 2068 RESTRICT = neqsel, 2069 JOIN = neqjoinsel); 2070 2071CREATE OPERATOR < ( 2072 PROCEDURE = isnlt, 2073 LEFTARG = ismn13, 2074 RIGHTARG = ismn, 2075 COMMUTATOR = >, 2076 NEGATOR = >=, 2077 RESTRICT = scalarltsel, 2078 JOIN = scalarltjoinsel); 2079CREATE OPERATOR <= ( 2080 PROCEDURE = isnle, 2081 LEFTARG = ismn13, 2082 RIGHTARG = ismn, 2083 COMMUTATOR = >=, 2084 NEGATOR = >, 2085 RESTRICT = scalarltsel, 2086 JOIN = scalarltjoinsel); 2087CREATE OPERATOR = ( 2088 PROCEDURE = isneq, 2089 LEFTARG = ismn13, 2090 RIGHTARG = ismn, 2091 COMMUTATOR = =, 2092 NEGATOR = <>, 2093 RESTRICT = eqsel, 2094 JOIN = eqjoinsel, 2095 MERGES, 2096 HASHES); 2097CREATE OPERATOR >= ( 2098 PROCEDURE = isnge, 2099 LEFTARG = ismn13, 2100 RIGHTARG = ismn, 2101 COMMUTATOR = <=, 2102 NEGATOR = <, 2103 RESTRICT = scalargtsel, 2104 JOIN = scalargtjoinsel ); 2105CREATE OPERATOR > ( 2106 PROCEDURE = isngt, 2107 LEFTARG = ismn13, 2108 RIGHTARG = ismn, 2109 COMMUTATOR = <, 2110 NEGATOR = <=, 2111 RESTRICT = scalargtsel, 2112 JOIN = scalargtjoinsel ); 2113CREATE OPERATOR <> ( 2114 PROCEDURE = isnne, 2115 LEFTARG = ismn13, 2116 RIGHTARG = ismn, 2117 COMMUTATOR = <>, 2118 NEGATOR = =, 2119 RESTRICT = neqsel, 2120 JOIN = neqjoinsel); 2121 2122-- 2123-- ISMN operators: 2124-- 2125--------------------------------------------------- 2126CREATE OPERATOR < ( 2127 PROCEDURE = isnlt, 2128 LEFTARG = ismn, 2129 RIGHTARG = ismn, 2130 COMMUTATOR = >, 2131 NEGATOR = >=, 2132 RESTRICT = scalarltsel, 2133 JOIN = scalarltjoinsel); 2134CREATE OPERATOR <= ( 2135 PROCEDURE = isnle, 2136 LEFTARG = ismn, 2137 RIGHTARG = ismn, 2138 COMMUTATOR = >=, 2139 NEGATOR = >, 2140 RESTRICT = scalarltsel, 2141 JOIN = scalarltjoinsel); 2142CREATE OPERATOR = ( 2143 PROCEDURE = isneq, 2144 LEFTARG = ismn, 2145 RIGHTARG = ismn, 2146 COMMUTATOR = =, 2147 NEGATOR = <>, 2148 RESTRICT = eqsel, 2149 JOIN = eqjoinsel, 2150 MERGES, 2151 HASHES); 2152CREATE OPERATOR >= ( 2153 PROCEDURE = isnge, 2154 LEFTARG = ismn, 2155 RIGHTARG = ismn, 2156 COMMUTATOR = <=, 2157 NEGATOR = <, 2158 RESTRICT = scalargtsel, 2159 JOIN = scalargtjoinsel ); 2160CREATE OPERATOR > ( 2161 PROCEDURE = isngt, 2162 LEFTARG = ismn, 2163 RIGHTARG = ismn, 2164 COMMUTATOR = <, 2165 NEGATOR = <=, 2166 RESTRICT = scalargtsel, 2167 JOIN = scalargtjoinsel ); 2168CREATE OPERATOR <> ( 2169 PROCEDURE = isnne, 2170 LEFTARG = ismn, 2171 RIGHTARG = ismn, 2172 COMMUTATOR = <>, 2173 NEGATOR = =, 2174 RESTRICT = neqsel, 2175 JOIN = neqjoinsel); 2176 2177CREATE OPERATOR < ( 2178 PROCEDURE = isnlt, 2179 LEFTARG = ismn, 2180 RIGHTARG = ismn13, 2181 COMMUTATOR = >, 2182 NEGATOR = >=, 2183 RESTRICT = scalarltsel, 2184 JOIN = scalarltjoinsel); 2185CREATE OPERATOR <= ( 2186 PROCEDURE = isnle, 2187 LEFTARG = ismn, 2188 RIGHTARG = ismn13, 2189 COMMUTATOR = >=, 2190 NEGATOR = >, 2191 RESTRICT = scalarltsel, 2192 JOIN = scalarltjoinsel); 2193CREATE OPERATOR = ( 2194 PROCEDURE = isneq, 2195 LEFTARG = ismn, 2196 RIGHTARG = ismn13, 2197 COMMUTATOR = =, 2198 NEGATOR = <>, 2199 RESTRICT = eqsel, 2200 JOIN = eqjoinsel, 2201 MERGES, 2202 HASHES); 2203CREATE OPERATOR >= ( 2204 PROCEDURE = isnge, 2205 LEFTARG = ismn, 2206 RIGHTARG = ismn13, 2207 COMMUTATOR = <=, 2208 NEGATOR = <, 2209 RESTRICT = scalargtsel, 2210 JOIN = scalargtjoinsel ); 2211CREATE OPERATOR > ( 2212 PROCEDURE = isngt, 2213 LEFTARG = ismn, 2214 RIGHTARG = ismn13, 2215 COMMUTATOR = <, 2216 NEGATOR = <=, 2217 RESTRICT = scalargtsel, 2218 JOIN = scalargtjoinsel ); 2219CREATE OPERATOR <> ( 2220 PROCEDURE = isnne, 2221 LEFTARG = ismn, 2222 RIGHTARG = ismn13, 2223 COMMUTATOR = <>, 2224 NEGATOR = =, 2225 RESTRICT = neqsel, 2226 JOIN = neqjoinsel); 2227 2228CREATE OPERATOR < ( 2229 PROCEDURE = isnlt, 2230 LEFTARG = ismn, 2231 RIGHTARG = ean13, 2232 COMMUTATOR = >, 2233 NEGATOR = >=, 2234 RESTRICT = scalarltsel, 2235 JOIN = scalarltjoinsel); 2236CREATE OPERATOR <= ( 2237 PROCEDURE = isnle, 2238 LEFTARG = ismn, 2239 RIGHTARG = ean13, 2240 COMMUTATOR = >=, 2241 NEGATOR = >, 2242 RESTRICT = scalarltsel, 2243 JOIN = scalarltjoinsel); 2244CREATE OPERATOR = ( 2245 PROCEDURE = isneq, 2246 LEFTARG = ismn, 2247 RIGHTARG = ean13, 2248 COMMUTATOR = =, 2249 NEGATOR = <>, 2250 RESTRICT = eqsel, 2251 JOIN = eqjoinsel, 2252 MERGES, 2253 HASHES); 2254CREATE OPERATOR >= ( 2255 PROCEDURE = isnge, 2256 LEFTARG = ismn, 2257 RIGHTARG = ean13, 2258 COMMUTATOR = <=, 2259 NEGATOR = <, 2260 RESTRICT = scalargtsel, 2261 JOIN = scalargtjoinsel ); 2262CREATE OPERATOR > ( 2263 PROCEDURE = isngt, 2264 LEFTARG = ismn, 2265 RIGHTARG = ean13, 2266 COMMUTATOR = <, 2267 NEGATOR = <=, 2268 RESTRICT = scalargtsel, 2269 JOIN = scalargtjoinsel ); 2270CREATE OPERATOR <> ( 2271 PROCEDURE = isnne, 2272 LEFTARG = ismn, 2273 RIGHTARG = ean13, 2274 COMMUTATOR = <>, 2275 NEGATOR = =, 2276 RESTRICT = neqsel, 2277 JOIN = neqjoinsel); 2278 2279-- 2280-- ISSN13 operators: 2281-- 2282--------------------------------------------------- 2283CREATE OPERATOR < ( 2284 PROCEDURE = isnlt, 2285 LEFTARG = issn13, 2286 RIGHTARG = issn13, 2287 COMMUTATOR = >, 2288 NEGATOR = >=, 2289 RESTRICT = scalarltsel, 2290 JOIN = scalarltjoinsel); 2291CREATE OPERATOR <= ( 2292 PROCEDURE = isnle, 2293 LEFTARG = issn13, 2294 RIGHTARG = issn13, 2295 COMMUTATOR = >=, 2296 NEGATOR = >, 2297 RESTRICT = scalarltsel, 2298 JOIN = scalarltjoinsel); 2299CREATE OPERATOR = ( 2300 PROCEDURE = isneq, 2301 LEFTARG = issn13, 2302 RIGHTARG = issn13, 2303 COMMUTATOR = =, 2304 NEGATOR = <>, 2305 RESTRICT = eqsel, 2306 JOIN = eqjoinsel, 2307 MERGES, 2308 HASHES); 2309CREATE OPERATOR >= ( 2310 PROCEDURE = isnge, 2311 LEFTARG = issn13, 2312 RIGHTARG = issn13, 2313 COMMUTATOR = <=, 2314 NEGATOR = <, 2315 RESTRICT = scalargtsel, 2316 JOIN = scalargtjoinsel ); 2317CREATE OPERATOR > ( 2318 PROCEDURE = isngt, 2319 LEFTARG = issn13, 2320 RIGHTARG = issn13, 2321 COMMUTATOR = <, 2322 NEGATOR = <=, 2323 RESTRICT = scalargtsel, 2324 JOIN = scalargtjoinsel ); 2325CREATE OPERATOR <> ( 2326 PROCEDURE = isnne, 2327 LEFTARG = issn13, 2328 RIGHTARG = issn13, 2329 COMMUTATOR = <>, 2330 NEGATOR = =, 2331 RESTRICT = neqsel, 2332 JOIN = neqjoinsel); 2333 2334CREATE OPERATOR < ( 2335 PROCEDURE = isnlt, 2336 LEFTARG = issn13, 2337 RIGHTARG = issn, 2338 COMMUTATOR = >, 2339 NEGATOR = >=, 2340 RESTRICT = scalarltsel, 2341 JOIN = scalarltjoinsel); 2342CREATE OPERATOR <= ( 2343 PROCEDURE = isnle, 2344 LEFTARG = issn13, 2345 RIGHTARG = issn, 2346 COMMUTATOR = >=, 2347 NEGATOR = >, 2348 RESTRICT = scalarltsel, 2349 JOIN = scalarltjoinsel); 2350CREATE OPERATOR = ( 2351 PROCEDURE = isneq, 2352 LEFTARG = issn13, 2353 RIGHTARG = issn, 2354 COMMUTATOR = =, 2355 NEGATOR = <>, 2356 RESTRICT = eqsel, 2357 JOIN = eqjoinsel, 2358 MERGES, 2359 HASHES); 2360CREATE OPERATOR >= ( 2361 PROCEDURE = isnge, 2362 LEFTARG = issn13, 2363 RIGHTARG = issn, 2364 COMMUTATOR = <=, 2365 NEGATOR = <, 2366 RESTRICT = scalargtsel, 2367 JOIN = scalargtjoinsel ); 2368CREATE OPERATOR > ( 2369 PROCEDURE = isngt, 2370 LEFTARG = issn13, 2371 RIGHTARG = issn, 2372 COMMUTATOR = <, 2373 NEGATOR = <=, 2374 RESTRICT = scalargtsel, 2375 JOIN = scalargtjoinsel ); 2376CREATE OPERATOR <> ( 2377 PROCEDURE = isnne, 2378 LEFTARG = issn13, 2379 RIGHTARG = issn, 2380 COMMUTATOR = <>, 2381 NEGATOR = =, 2382 RESTRICT = neqsel, 2383 JOIN = neqjoinsel); 2384 2385CREATE OPERATOR < ( 2386 PROCEDURE = isnlt, 2387 LEFTARG = issn13, 2388 RIGHTARG = ean13, 2389 COMMUTATOR = >, 2390 NEGATOR = >=, 2391 RESTRICT = scalarltsel, 2392 JOIN = scalarltjoinsel); 2393CREATE OPERATOR <= ( 2394 PROCEDURE = isnle, 2395 LEFTARG = issn13, 2396 RIGHTARG = ean13, 2397 COMMUTATOR = >=, 2398 NEGATOR = >, 2399 RESTRICT = scalarltsel, 2400 JOIN = scalarltjoinsel); 2401CREATE OPERATOR = ( 2402 PROCEDURE = isneq, 2403 LEFTARG = issn13, 2404 RIGHTARG = ean13, 2405 COMMUTATOR = =, 2406 NEGATOR = <>, 2407 RESTRICT = eqsel, 2408 JOIN = eqjoinsel, 2409 MERGES, 2410 HASHES); 2411CREATE OPERATOR >= ( 2412 PROCEDURE = isnge, 2413 LEFTARG = issn13, 2414 RIGHTARG = ean13, 2415 COMMUTATOR = <=, 2416 NEGATOR = <, 2417 RESTRICT = scalargtsel, 2418 JOIN = scalargtjoinsel ); 2419CREATE OPERATOR > ( 2420 PROCEDURE = isngt, 2421 LEFTARG = issn13, 2422 RIGHTARG = ean13, 2423 COMMUTATOR = <, 2424 NEGATOR = <=, 2425 RESTRICT = scalargtsel, 2426 JOIN = scalargtjoinsel ); 2427CREATE OPERATOR <> ( 2428 PROCEDURE = isnne, 2429 LEFTARG = issn13, 2430 RIGHTARG = ean13, 2431 COMMUTATOR = <>, 2432 NEGATOR = =, 2433 RESTRICT = neqsel, 2434 JOIN = neqjoinsel); 2435 2436-- 2437-- ISSN operators: 2438-- 2439--------------------------------------------------- 2440CREATE OPERATOR < ( 2441 PROCEDURE = isnlt, 2442 LEFTARG = issn, 2443 RIGHTARG = issn, 2444 COMMUTATOR = >, 2445 NEGATOR = >=, 2446 RESTRICT = scalarltsel, 2447 JOIN = scalarltjoinsel); 2448CREATE OPERATOR <= ( 2449 PROCEDURE = isnle, 2450 LEFTARG = issn, 2451 RIGHTARG = issn, 2452 COMMUTATOR = >=, 2453 NEGATOR = >, 2454 RESTRICT = scalarltsel, 2455 JOIN = scalarltjoinsel); 2456CREATE OPERATOR = ( 2457 PROCEDURE = isneq, 2458 LEFTARG = issn, 2459 RIGHTARG = issn, 2460 COMMUTATOR = =, 2461 NEGATOR = <>, 2462 RESTRICT = eqsel, 2463 JOIN = eqjoinsel, 2464 MERGES, 2465 HASHES); 2466CREATE OPERATOR >= ( 2467 PROCEDURE = isnge, 2468 LEFTARG = issn, 2469 RIGHTARG = issn, 2470 COMMUTATOR = <=, 2471 NEGATOR = <, 2472 RESTRICT = scalargtsel, 2473 JOIN = scalargtjoinsel ); 2474CREATE OPERATOR > ( 2475 PROCEDURE = isngt, 2476 LEFTARG = issn, 2477 RIGHTARG = issn, 2478 COMMUTATOR = <, 2479 NEGATOR = <=, 2480 RESTRICT = scalargtsel, 2481 JOIN = scalargtjoinsel ); 2482CREATE OPERATOR <> ( 2483 PROCEDURE = isnne, 2484 LEFTARG = issn, 2485 RIGHTARG = issn, 2486 COMMUTATOR = <>, 2487 NEGATOR = =, 2488 RESTRICT = neqsel, 2489 JOIN = neqjoinsel); 2490 2491CREATE OPERATOR < ( 2492 PROCEDURE = isnlt, 2493 LEFTARG = issn, 2494 RIGHTARG = issn13, 2495 COMMUTATOR = >, 2496 NEGATOR = >=, 2497 RESTRICT = scalarltsel, 2498 JOIN = scalarltjoinsel); 2499CREATE OPERATOR <= ( 2500 PROCEDURE = isnle, 2501 LEFTARG = issn, 2502 RIGHTARG = issn13, 2503 COMMUTATOR = >=, 2504 NEGATOR = >, 2505 RESTRICT = scalarltsel, 2506 JOIN = scalarltjoinsel); 2507CREATE OPERATOR = ( 2508 PROCEDURE = isneq, 2509 LEFTARG = issn, 2510 RIGHTARG = issn13, 2511 COMMUTATOR = =, 2512 NEGATOR = <>, 2513 RESTRICT = eqsel, 2514 JOIN = eqjoinsel, 2515 MERGES, 2516 HASHES); 2517CREATE OPERATOR >= ( 2518 PROCEDURE = isnge, 2519 LEFTARG = issn, 2520 RIGHTARG = issn13, 2521 COMMUTATOR = <=, 2522 NEGATOR = <, 2523 RESTRICT = scalargtsel, 2524 JOIN = scalargtjoinsel ); 2525CREATE OPERATOR > ( 2526 PROCEDURE = isngt, 2527 LEFTARG = issn, 2528 RIGHTARG = issn13, 2529 COMMUTATOR = <, 2530 NEGATOR = <=, 2531 RESTRICT = scalargtsel, 2532 JOIN = scalargtjoinsel ); 2533CREATE OPERATOR <> ( 2534 PROCEDURE = isnne, 2535 LEFTARG = issn, 2536 RIGHTARG = issn13, 2537 COMMUTATOR = <>, 2538 NEGATOR = =, 2539 RESTRICT = neqsel, 2540 JOIN = neqjoinsel); 2541 2542CREATE OPERATOR < ( 2543 PROCEDURE = isnlt, 2544 LEFTARG = issn, 2545 RIGHTARG = ean13, 2546 COMMUTATOR = >, 2547 NEGATOR = >=, 2548 RESTRICT = scalarltsel, 2549 JOIN = scalarltjoinsel); 2550CREATE OPERATOR <= ( 2551 PROCEDURE = isnle, 2552 LEFTARG = issn, 2553 RIGHTARG = ean13, 2554 COMMUTATOR = >=, 2555 NEGATOR = >, 2556 RESTRICT = scalarltsel, 2557 JOIN = scalarltjoinsel); 2558CREATE OPERATOR = ( 2559 PROCEDURE = isneq, 2560 LEFTARG = issn, 2561 RIGHTARG = ean13, 2562 COMMUTATOR = =, 2563 NEGATOR = <>, 2564 RESTRICT = eqsel, 2565 JOIN = eqjoinsel, 2566 MERGES, 2567 HASHES); 2568CREATE OPERATOR >= ( 2569 PROCEDURE = isnge, 2570 LEFTARG = issn, 2571 RIGHTARG = ean13, 2572 COMMUTATOR = <=, 2573 NEGATOR = <, 2574 RESTRICT = scalargtsel, 2575 JOIN = scalargtjoinsel ); 2576CREATE OPERATOR > ( 2577 PROCEDURE = isngt, 2578 LEFTARG = issn, 2579 RIGHTARG = ean13, 2580 COMMUTATOR = <, 2581 NEGATOR = <=, 2582 RESTRICT = scalargtsel, 2583 JOIN = scalargtjoinsel ); 2584CREATE OPERATOR <> ( 2585 PROCEDURE = isnne, 2586 LEFTARG = issn, 2587 RIGHTARG = ean13, 2588 COMMUTATOR = <>, 2589 NEGATOR = =, 2590 RESTRICT = neqsel, 2591 JOIN = neqjoinsel); 2592 2593-- 2594-- UPC operators: 2595-- 2596--------------------------------------------------- 2597CREATE OPERATOR < ( 2598 PROCEDURE = isnlt, 2599 LEFTARG = upc, 2600 RIGHTARG = upc, 2601 COMMUTATOR = >, 2602 NEGATOR = >=, 2603 RESTRICT = scalarltsel, 2604 JOIN = scalarltjoinsel); 2605CREATE OPERATOR <= ( 2606 PROCEDURE = isnle, 2607 LEFTARG = upc, 2608 RIGHTARG = upc, 2609 COMMUTATOR = >=, 2610 NEGATOR = >, 2611 RESTRICT = scalarltsel, 2612 JOIN = scalarltjoinsel); 2613CREATE OPERATOR = ( 2614 PROCEDURE = isneq, 2615 LEFTARG = upc, 2616 RIGHTARG = upc, 2617 COMMUTATOR = =, 2618 NEGATOR = <>, 2619 RESTRICT = eqsel, 2620 JOIN = eqjoinsel, 2621 MERGES, 2622 HASHES); 2623CREATE OPERATOR >= ( 2624 PROCEDURE = isnge, 2625 LEFTARG = upc, 2626 RIGHTARG = upc, 2627 COMMUTATOR = <=, 2628 NEGATOR = <, 2629 RESTRICT = scalargtsel, 2630 JOIN = scalargtjoinsel ); 2631CREATE OPERATOR > ( 2632 PROCEDURE = isngt, 2633 LEFTARG = upc, 2634 RIGHTARG = upc, 2635 COMMUTATOR = <, 2636 NEGATOR = <=, 2637 RESTRICT = scalargtsel, 2638 JOIN = scalargtjoinsel ); 2639CREATE OPERATOR <> ( 2640 PROCEDURE = isnne, 2641 LEFTARG = upc, 2642 RIGHTARG = upc, 2643 COMMUTATOR = <>, 2644 NEGATOR = =, 2645 RESTRICT = neqsel, 2646 JOIN = neqjoinsel); 2647 2648CREATE OPERATOR < ( 2649 PROCEDURE = isnlt, 2650 LEFTARG = upc, 2651 RIGHTARG = ean13, 2652 COMMUTATOR = >, 2653 NEGATOR = >=, 2654 RESTRICT = scalarltsel, 2655 JOIN = scalarltjoinsel); 2656CREATE OPERATOR <= ( 2657 PROCEDURE = isnle, 2658 LEFTARG = upc, 2659 RIGHTARG = ean13, 2660 COMMUTATOR = >=, 2661 NEGATOR = >, 2662 RESTRICT = scalarltsel, 2663 JOIN = scalarltjoinsel); 2664CREATE OPERATOR = ( 2665 PROCEDURE = isneq, 2666 LEFTARG = upc, 2667 RIGHTARG = ean13, 2668 COMMUTATOR = =, 2669 NEGATOR = <>, 2670 RESTRICT = eqsel, 2671 JOIN = eqjoinsel, 2672 MERGES, 2673 HASHES); 2674CREATE OPERATOR >= ( 2675 PROCEDURE = isnge, 2676 LEFTARG = upc, 2677 RIGHTARG = ean13, 2678 COMMUTATOR = <=, 2679 NEGATOR = <, 2680 RESTRICT = scalargtsel, 2681 JOIN = scalargtjoinsel ); 2682CREATE OPERATOR > ( 2683 PROCEDURE = isngt, 2684 LEFTARG = upc, 2685 RIGHTARG = ean13, 2686 COMMUTATOR = <, 2687 NEGATOR = <=, 2688 RESTRICT = scalargtsel, 2689 JOIN = scalargtjoinsel ); 2690CREATE OPERATOR <> ( 2691 PROCEDURE = isnne, 2692 LEFTARG = upc, 2693 RIGHTARG = ean13, 2694 COMMUTATOR = <>, 2695 NEGATOR = =, 2696 RESTRICT = neqsel, 2697 JOIN = neqjoinsel); 2698 2699-- 2700-- Operator families for the various operator classes: 2701-- 2702--------------------------------------------------- 2703 2704CREATE OPERATOR FAMILY isn_ops USING btree; 2705CREATE OPERATOR FAMILY isn_ops USING hash; 2706 2707-- 2708-- Operator classes: 2709-- 2710--------------------------------------------------- 2711-- EAN13: 2712CREATE FUNCTION btean13cmp(ean13, ean13) 2713 RETURNS int4 2714 AS 'btint8cmp' 2715 LANGUAGE 'internal' 2716 IMMUTABLE STRICT 2717 PARALLEL SAFE; 2718 2719CREATE OPERATOR CLASS ean13_ops DEFAULT 2720 FOR TYPE ean13 USING btree FAMILY isn_ops AS 2721 OPERATOR 1 <, 2722 OPERATOR 2 <=, 2723 OPERATOR 3 =, 2724 OPERATOR 4 >=, 2725 OPERATOR 5 >, 2726 FUNCTION 1 btean13cmp(ean13, ean13); 2727 2728CREATE FUNCTION hashean13(ean13) 2729 RETURNS int4 2730 AS 'hashint8' 2731 LANGUAGE 'internal' IMMUTABLE STRICT 2732 PARALLEL SAFE; 2733 2734CREATE OPERATOR CLASS ean13_ops DEFAULT 2735 FOR TYPE ean13 USING hash FAMILY isn_ops AS 2736 OPERATOR 1 =, 2737 FUNCTION 1 hashean13(ean13); 2738 2739-- EAN13 vs other types: 2740CREATE FUNCTION btean13cmp(ean13, isbn13) 2741 RETURNS int4 2742 AS 'btint8cmp' 2743 LANGUAGE 'internal' 2744 IMMUTABLE STRICT 2745 PARALLEL SAFE; 2746CREATE FUNCTION btean13cmp(ean13, ismn13) 2747 RETURNS int4 2748 AS 'btint8cmp' 2749 LANGUAGE 'internal' 2750 IMMUTABLE STRICT 2751 PARALLEL SAFE; 2752CREATE FUNCTION btean13cmp(ean13, issn13) 2753 RETURNS int4 2754 AS 'btint8cmp' 2755 LANGUAGE 'internal' 2756 IMMUTABLE STRICT 2757 PARALLEL SAFE; 2758CREATE FUNCTION btean13cmp(ean13, isbn) 2759 RETURNS int4 2760 AS 'btint8cmp' 2761 LANGUAGE 'internal' 2762 IMMUTABLE STRICT 2763 PARALLEL SAFE; 2764CREATE FUNCTION btean13cmp(ean13, ismn) 2765 RETURNS int4 2766 AS 'btint8cmp' 2767 LANGUAGE 'internal' 2768 IMMUTABLE STRICT 2769 PARALLEL SAFE; 2770CREATE FUNCTION btean13cmp(ean13, issn) 2771 RETURNS int4 2772 AS 'btint8cmp' 2773 LANGUAGE 'internal' 2774 IMMUTABLE STRICT 2775 PARALLEL SAFE; 2776CREATE FUNCTION btean13cmp(ean13, upc) 2777 RETURNS int4 2778 AS 'btint8cmp' 2779 LANGUAGE 'internal' 2780 IMMUTABLE STRICT 2781 PARALLEL SAFE; 2782 2783ALTER OPERATOR FAMILY isn_ops USING btree ADD 2784 OPERATOR 1 < (ean13, isbn13), 2785 OPERATOR 1 < (ean13, ismn13), 2786 OPERATOR 1 < (ean13, issn13), 2787 OPERATOR 1 < (ean13, isbn), 2788 OPERATOR 1 < (ean13, ismn), 2789 OPERATOR 1 < (ean13, issn), 2790 OPERATOR 1 < (ean13, upc), 2791 OPERATOR 2 <= (ean13, isbn13), 2792 OPERATOR 2 <= (ean13, ismn13), 2793 OPERATOR 2 <= (ean13, issn13), 2794 OPERATOR 2 <= (ean13, isbn), 2795 OPERATOR 2 <= (ean13, ismn), 2796 OPERATOR 2 <= (ean13, issn), 2797 OPERATOR 2 <= (ean13, upc), 2798 OPERATOR 3 = (ean13, isbn13), 2799 OPERATOR 3 = (ean13, ismn13), 2800 OPERATOR 3 = (ean13, issn13), 2801 OPERATOR 3 = (ean13, isbn), 2802 OPERATOR 3 = (ean13, ismn), 2803 OPERATOR 3 = (ean13, issn), 2804 OPERATOR 3 = (ean13, upc), 2805 OPERATOR 4 >= (ean13, isbn13), 2806 OPERATOR 4 >= (ean13, ismn13), 2807 OPERATOR 4 >= (ean13, issn13), 2808 OPERATOR 4 >= (ean13, isbn), 2809 OPERATOR 4 >= (ean13, ismn), 2810 OPERATOR 4 >= (ean13, issn), 2811 OPERATOR 4 >= (ean13, upc), 2812 OPERATOR 5 > (ean13, isbn13), 2813 OPERATOR 5 > (ean13, ismn13), 2814 OPERATOR 5 > (ean13, issn13), 2815 OPERATOR 5 > (ean13, isbn), 2816 OPERATOR 5 > (ean13, ismn), 2817 OPERATOR 5 > (ean13, issn), 2818 OPERATOR 5 > (ean13, upc), 2819 FUNCTION 1 btean13cmp(ean13, isbn13), 2820 FUNCTION 1 btean13cmp(ean13, ismn13), 2821 FUNCTION 1 btean13cmp(ean13, issn13), 2822 FUNCTION 1 btean13cmp(ean13, isbn), 2823 FUNCTION 1 btean13cmp(ean13, ismn), 2824 FUNCTION 1 btean13cmp(ean13, issn), 2825 FUNCTION 1 btean13cmp(ean13, upc); 2826 2827ALTER OPERATOR FAMILY isn_ops USING hash ADD 2828 OPERATOR 1 = (ean13, isbn13), 2829 OPERATOR 1 = (ean13, ismn13), 2830 OPERATOR 1 = (ean13, issn13), 2831 OPERATOR 1 = (ean13, isbn), 2832 OPERATOR 1 = (ean13, ismn), 2833 OPERATOR 1 = (ean13, issn), 2834 OPERATOR 1 = (ean13, upc); 2835 2836--------------------------------------------------- 2837-- ISBN13: 2838CREATE FUNCTION btisbn13cmp(isbn13, isbn13) 2839 RETURNS int4 2840 AS 'btint8cmp' 2841 LANGUAGE 'internal' 2842 IMMUTABLE STRICT 2843 PARALLEL SAFE; 2844 2845CREATE OPERATOR CLASS isbn13_ops DEFAULT 2846 FOR TYPE isbn13 USING btree FAMILY isn_ops AS 2847 OPERATOR 1 <, 2848 OPERATOR 2 <=, 2849 OPERATOR 3 =, 2850 OPERATOR 4 >=, 2851 OPERATOR 5 >, 2852 FUNCTION 1 btisbn13cmp(isbn13, isbn13); 2853 2854CREATE FUNCTION hashisbn13(isbn13) 2855 RETURNS int4 2856 AS 'hashint8' 2857 LANGUAGE 'internal' 2858 IMMUTABLE STRICT 2859 PARALLEL SAFE; 2860 2861CREATE OPERATOR CLASS isbn13_ops DEFAULT 2862 FOR TYPE isbn13 USING hash FAMILY isn_ops AS 2863 OPERATOR 1 =, 2864 FUNCTION 1 hashisbn13(isbn13); 2865 2866-- ISBN13 vs other types: 2867CREATE FUNCTION btisbn13cmp(isbn13, ean13) 2868 RETURNS int4 2869 AS 'btint8cmp' 2870 LANGUAGE 'internal' 2871 IMMUTABLE STRICT 2872 PARALLEL SAFE; 2873CREATE FUNCTION btisbn13cmp(isbn13, isbn) 2874 RETURNS int4 2875 AS 'btint8cmp' 2876 LANGUAGE 'internal' 2877 IMMUTABLE STRICT 2878 PARALLEL SAFE; 2879 2880ALTER OPERATOR FAMILY isn_ops USING btree ADD 2881 OPERATOR 1 < (isbn13, ean13), 2882 OPERATOR 1 < (isbn13, isbn), 2883 OPERATOR 2 <= (isbn13, ean13), 2884 OPERATOR 2 <= (isbn13, isbn), 2885 OPERATOR 3 = (isbn13, ean13), 2886 OPERATOR 3 = (isbn13, isbn), 2887 OPERATOR 4 >= (isbn13, ean13), 2888 OPERATOR 4 >= (isbn13, isbn), 2889 OPERATOR 5 > (isbn13, ean13), 2890 OPERATOR 5 > (isbn13, isbn), 2891 FUNCTION 1 btisbn13cmp(isbn13, ean13), 2892 FUNCTION 1 btisbn13cmp(isbn13, isbn); 2893 2894ALTER OPERATOR FAMILY isn_ops USING hash ADD 2895 OPERATOR 1 = (isbn13, ean13), 2896 OPERATOR 1 = (isbn13, isbn); 2897 2898--------------------------------------------------- 2899-- ISBN: 2900CREATE FUNCTION btisbncmp(isbn, isbn) 2901 RETURNS int4 2902 AS 'btint8cmp' 2903 LANGUAGE 'internal' 2904 IMMUTABLE STRICT 2905 PARALLEL SAFE; 2906 2907CREATE OPERATOR CLASS isbn_ops DEFAULT 2908 FOR TYPE isbn USING btree FAMILY isn_ops AS 2909 OPERATOR 1 <, 2910 OPERATOR 2 <=, 2911 OPERATOR 3 =, 2912 OPERATOR 4 >=, 2913 OPERATOR 5 >, 2914 FUNCTION 1 btisbncmp(isbn, isbn); 2915 2916CREATE FUNCTION hashisbn(isbn) 2917 RETURNS int4 2918 AS 'hashint8' 2919 LANGUAGE 'internal' 2920 IMMUTABLE STRICT 2921 PARALLEL SAFE; 2922 2923CREATE OPERATOR CLASS isbn_ops DEFAULT 2924 FOR TYPE isbn USING hash FAMILY isn_ops AS 2925 OPERATOR 1 =, 2926 FUNCTION 1 hashisbn(isbn); 2927 2928-- ISBN vs other types: 2929CREATE FUNCTION btisbncmp(isbn, ean13) 2930 RETURNS int4 2931 AS 'btint8cmp' 2932 LANGUAGE 'internal' 2933 IMMUTABLE STRICT 2934 PARALLEL SAFE; 2935CREATE FUNCTION btisbncmp(isbn, isbn13) 2936 RETURNS int4 2937 AS 'btint8cmp' 2938 LANGUAGE 'internal' 2939 IMMUTABLE STRICT 2940 PARALLEL SAFE; 2941 2942ALTER OPERATOR FAMILY isn_ops USING btree ADD 2943 OPERATOR 1 < (isbn, ean13), 2944 OPERATOR 1 < (isbn, isbn13), 2945 OPERATOR 2 <= (isbn, ean13), 2946 OPERATOR 2 <= (isbn, isbn13), 2947 OPERATOR 3 = (isbn, ean13), 2948 OPERATOR 3 = (isbn, isbn13), 2949 OPERATOR 4 >= (isbn, ean13), 2950 OPERATOR 4 >= (isbn, isbn13), 2951 OPERATOR 5 > (isbn, ean13), 2952 OPERATOR 5 > (isbn, isbn13), 2953 FUNCTION 1 btisbncmp(isbn, ean13), 2954 FUNCTION 1 btisbncmp(isbn, isbn13); 2955 2956ALTER OPERATOR FAMILY isn_ops USING hash ADD 2957 OPERATOR 1 = (isbn, ean13), 2958 OPERATOR 1 = (isbn, isbn13); 2959 2960--------------------------------------------------- 2961-- ISMN13: 2962CREATE FUNCTION btismn13cmp(ismn13, ismn13) 2963 RETURNS int4 2964 AS 'btint8cmp' 2965 LANGUAGE 'internal' 2966 IMMUTABLE STRICT 2967 PARALLEL SAFE; 2968 2969CREATE OPERATOR CLASS ismn13_ops DEFAULT 2970 FOR TYPE ismn13 USING btree FAMILY isn_ops AS 2971 OPERATOR 1 <, 2972 OPERATOR 2 <=, 2973 OPERATOR 3 =, 2974 OPERATOR 4 >=, 2975 OPERATOR 5 >, 2976 FUNCTION 1 btismn13cmp(ismn13, ismn13); 2977 2978CREATE FUNCTION hashismn13(ismn13) 2979 RETURNS int4 2980 AS 'hashint8' 2981 LANGUAGE 'internal' 2982 IMMUTABLE STRICT 2983 PARALLEL SAFE; 2984 2985CREATE OPERATOR CLASS ismn13_ops DEFAULT 2986 FOR TYPE ismn13 USING hash FAMILY isn_ops AS 2987 OPERATOR 1 =, 2988 FUNCTION 1 hashismn13(ismn13); 2989 2990-- ISMN13 vs other types: 2991CREATE FUNCTION btismn13cmp(ismn13, ean13) 2992 RETURNS int4 2993 AS 'btint8cmp' 2994 LANGUAGE 'internal' 2995 IMMUTABLE STRICT 2996 PARALLEL SAFE; 2997CREATE FUNCTION btismn13cmp(ismn13, ismn) 2998 RETURNS int4 2999 AS 'btint8cmp' 3000 LANGUAGE 'internal' 3001 IMMUTABLE STRICT 3002 PARALLEL SAFE; 3003 3004ALTER OPERATOR FAMILY isn_ops USING btree ADD 3005 OPERATOR 1 < (ismn13, ean13), 3006 OPERATOR 1 < (ismn13, ismn), 3007 OPERATOR 2 <= (ismn13, ean13), 3008 OPERATOR 2 <= (ismn13, ismn), 3009 OPERATOR 3 = (ismn13, ean13), 3010 OPERATOR 3 = (ismn13, ismn), 3011 OPERATOR 4 >= (ismn13, ean13), 3012 OPERATOR 4 >= (ismn13, ismn), 3013 OPERATOR 5 > (ismn13, ean13), 3014 OPERATOR 5 > (ismn13, ismn), 3015 FUNCTION 1 btismn13cmp(ismn13, ean13), 3016 FUNCTION 1 btismn13cmp(ismn13, ismn); 3017 3018ALTER OPERATOR FAMILY isn_ops USING hash ADD 3019 OPERATOR 1 = (ismn13, ean13), 3020 OPERATOR 1 = (ismn13, ismn); 3021 3022--------------------------------------------------- 3023-- ISMN: 3024CREATE FUNCTION btismncmp(ismn, ismn) 3025 RETURNS int4 3026 AS 'btint8cmp' 3027 LANGUAGE 'internal' 3028 IMMUTABLE STRICT 3029 PARALLEL SAFE; 3030 3031CREATE OPERATOR CLASS ismn_ops DEFAULT 3032 FOR TYPE ismn USING btree FAMILY isn_ops AS 3033 OPERATOR 1 <, 3034 OPERATOR 2 <=, 3035 OPERATOR 3 =, 3036 OPERATOR 4 >=, 3037 OPERATOR 5 >, 3038 FUNCTION 1 btismncmp(ismn, ismn); 3039 3040CREATE FUNCTION hashismn(ismn) 3041 RETURNS int4 3042 AS 'hashint8' 3043 LANGUAGE 'internal' 3044 IMMUTABLE STRICT 3045 PARALLEL SAFE; 3046 3047CREATE OPERATOR CLASS ismn_ops DEFAULT 3048 FOR TYPE ismn USING hash FAMILY isn_ops AS 3049 OPERATOR 1 =, 3050 FUNCTION 1 hashismn(ismn); 3051 3052-- ISMN vs other types: 3053CREATE FUNCTION btismncmp(ismn, ean13) 3054 RETURNS int4 3055 AS 'btint8cmp' 3056 LANGUAGE 'internal' 3057 IMMUTABLE STRICT 3058 PARALLEL SAFE; 3059CREATE FUNCTION btismncmp(ismn, ismn13) 3060 RETURNS int4 3061 AS 'btint8cmp' 3062 LANGUAGE 'internal' 3063 IMMUTABLE STRICT 3064 PARALLEL SAFE; 3065 3066ALTER OPERATOR FAMILY isn_ops USING btree ADD 3067 OPERATOR 1 < (ismn, ean13), 3068 OPERATOR 1 < (ismn, ismn13), 3069 OPERATOR 2 <= (ismn, ean13), 3070 OPERATOR 2 <= (ismn, ismn13), 3071 OPERATOR 3 = (ismn, ean13), 3072 OPERATOR 3 = (ismn, ismn13), 3073 OPERATOR 4 >= (ismn, ean13), 3074 OPERATOR 4 >= (ismn, ismn13), 3075 OPERATOR 5 > (ismn, ean13), 3076 OPERATOR 5 > (ismn, ismn13), 3077 FUNCTION 1 btismncmp(ismn, ean13), 3078 FUNCTION 1 btismncmp(ismn, ismn13); 3079 3080ALTER OPERATOR FAMILY isn_ops USING hash ADD 3081 OPERATOR 1 = (ismn, ean13), 3082 OPERATOR 1 = (ismn, ismn13); 3083 3084--------------------------------------------------- 3085-- ISSN13: 3086CREATE FUNCTION btissn13cmp(issn13, issn13) 3087 RETURNS int4 3088 AS 'btint8cmp' 3089 LANGUAGE 'internal' 3090 IMMUTABLE STRICT 3091 PARALLEL SAFE; 3092 3093CREATE OPERATOR CLASS issn13_ops DEFAULT 3094 FOR TYPE issn13 USING btree FAMILY isn_ops AS 3095 OPERATOR 1 <, 3096 OPERATOR 2 <=, 3097 OPERATOR 3 =, 3098 OPERATOR 4 >=, 3099 OPERATOR 5 >, 3100 FUNCTION 1 btissn13cmp(issn13, issn13); 3101 3102CREATE FUNCTION hashissn13(issn13) 3103 RETURNS int4 3104 AS 'hashint8' 3105 LANGUAGE 'internal' 3106 IMMUTABLE STRICT 3107 PARALLEL SAFE; 3108 3109CREATE OPERATOR CLASS issn13_ops DEFAULT 3110 FOR TYPE issn13 USING hash FAMILY isn_ops AS 3111 OPERATOR 1 =, 3112 FUNCTION 1 hashissn13(issn13); 3113 3114-- ISSN13 vs other types: 3115CREATE FUNCTION btissn13cmp(issn13, ean13) 3116 RETURNS int4 3117 AS 'btint8cmp' 3118 LANGUAGE 'internal' 3119 IMMUTABLE STRICT 3120 PARALLEL SAFE; 3121CREATE FUNCTION btissn13cmp(issn13, issn) 3122 RETURNS int4 3123 AS 'btint8cmp' 3124 LANGUAGE 'internal' 3125 IMMUTABLE STRICT 3126 PARALLEL SAFE; 3127 3128ALTER OPERATOR FAMILY isn_ops USING btree ADD 3129 OPERATOR 1 < (issn13, ean13), 3130 OPERATOR 1 < (issn13, issn), 3131 OPERATOR 2 <= (issn13, ean13), 3132 OPERATOR 2 <= (issn13, issn), 3133 OPERATOR 3 = (issn13, ean13), 3134 OPERATOR 3 = (issn13, issn), 3135 OPERATOR 4 >= (issn13, ean13), 3136 OPERATOR 4 >= (issn13, issn), 3137 OPERATOR 5 > (issn13, ean13), 3138 OPERATOR 5 > (issn13, issn), 3139 FUNCTION 1 btissn13cmp(issn13, ean13), 3140 FUNCTION 1 btissn13cmp(issn13, issn); 3141 3142ALTER OPERATOR FAMILY isn_ops USING hash ADD 3143 OPERATOR 1 = (issn13, ean13), 3144 OPERATOR 1 = (issn13, issn); 3145 3146--------------------------------------------------- 3147-- ISSN: 3148CREATE FUNCTION btissncmp(issn, issn) 3149 RETURNS int4 3150 AS 'btint8cmp' 3151 LANGUAGE 'internal' 3152 IMMUTABLE STRICT 3153 PARALLEL SAFE; 3154 3155CREATE OPERATOR CLASS issn_ops DEFAULT 3156 FOR TYPE issn USING btree FAMILY isn_ops AS 3157 OPERATOR 1 <, 3158 OPERATOR 2 <=, 3159 OPERATOR 3 =, 3160 OPERATOR 4 >=, 3161 OPERATOR 5 >, 3162 FUNCTION 1 btissncmp(issn, issn); 3163 3164CREATE FUNCTION hashissn(issn) 3165 RETURNS int4 3166 AS 'hashint8' 3167 LANGUAGE 'internal' 3168 IMMUTABLE STRICT 3169 PARALLEL SAFE; 3170 3171CREATE OPERATOR CLASS issn_ops DEFAULT 3172 FOR TYPE issn USING hash FAMILY isn_ops AS 3173 OPERATOR 1 =, 3174 FUNCTION 1 hashissn(issn); 3175 3176-- ISSN vs other types: 3177CREATE FUNCTION btissncmp(issn, ean13) 3178 RETURNS int4 3179 AS 'btint8cmp' 3180 LANGUAGE 'internal' 3181 IMMUTABLE STRICT 3182 PARALLEL SAFE; 3183CREATE FUNCTION btissncmp(issn, issn13) 3184 RETURNS int4 3185 AS 'btint8cmp' 3186 LANGUAGE 'internal' 3187 IMMUTABLE STRICT 3188 PARALLEL SAFE; 3189 3190ALTER OPERATOR FAMILY isn_ops USING btree ADD 3191 OPERATOR 1 < (issn, ean13), 3192 OPERATOR 1 < (issn, issn13), 3193 OPERATOR 2 <= (issn, ean13), 3194 OPERATOR 2 <= (issn, issn13), 3195 OPERATOR 3 = (issn, ean13), 3196 OPERATOR 3 = (issn, issn13), 3197 OPERATOR 4 >= (issn, ean13), 3198 OPERATOR 4 >= (issn, issn13), 3199 OPERATOR 5 > (issn, ean13), 3200 OPERATOR 5 > (issn, issn13), 3201 FUNCTION 1 btissncmp(issn, ean13), 3202 FUNCTION 1 btissncmp(issn, issn13); 3203 3204ALTER OPERATOR FAMILY isn_ops USING hash ADD 3205 OPERATOR 1 = (issn, ean13), 3206 OPERATOR 1 = (issn, issn13); 3207 3208--------------------------------------------------- 3209-- UPC: 3210CREATE FUNCTION btupccmp(upc, upc) 3211 RETURNS int4 3212 AS 'btint8cmp' 3213 LANGUAGE 'internal' 3214 IMMUTABLE STRICT 3215 PARALLEL SAFE; 3216 3217CREATE OPERATOR CLASS upc_ops DEFAULT 3218 FOR TYPE upc USING btree FAMILY isn_ops AS 3219 OPERATOR 1 <, 3220 OPERATOR 2 <=, 3221 OPERATOR 3 =, 3222 OPERATOR 4 >=, 3223 OPERATOR 5 >, 3224 FUNCTION 1 btupccmp(upc, upc); 3225 3226CREATE FUNCTION hashupc(upc) 3227 RETURNS int4 3228 AS 'hashint8' 3229 LANGUAGE 'internal' 3230 IMMUTABLE STRICT 3231 PARALLEL SAFE; 3232 3233CREATE OPERATOR CLASS upc_ops DEFAULT 3234 FOR TYPE upc USING hash FAMILY isn_ops AS 3235 OPERATOR 1 =, 3236 FUNCTION 1 hashupc(upc); 3237 3238-- UPC vs other types: 3239CREATE FUNCTION btupccmp(upc, ean13) 3240 RETURNS int4 3241 AS 'btint8cmp' 3242 LANGUAGE 'internal' 3243 IMMUTABLE STRICT 3244 PARALLEL SAFE; 3245 3246ALTER OPERATOR FAMILY isn_ops USING btree ADD 3247 OPERATOR 1 < (upc, ean13), 3248 OPERATOR 2 <= (upc, ean13), 3249 OPERATOR 3 = (upc, ean13), 3250 OPERATOR 4 >= (upc, ean13), 3251 OPERATOR 5 > (upc, ean13), 3252 FUNCTION 1 btupccmp(upc, ean13); 3253 3254ALTER OPERATOR FAMILY isn_ops USING hash ADD 3255 OPERATOR 1 = (upc, ean13); 3256 3257-- 3258-- Type casts: 3259-- 3260--------------------------------------------------- 3261CREATE FUNCTION isbn13(ean13) 3262RETURNS isbn13 3263AS 'MODULE_PATHNAME', 'isbn_cast_from_ean13' 3264LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; 3265CREATE FUNCTION ismn13(ean13) 3266RETURNS ismn13 3267AS 'MODULE_PATHNAME', 'ismn_cast_from_ean13' 3268LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; 3269CREATE FUNCTION issn13(ean13) 3270RETURNS issn13 3271AS 'MODULE_PATHNAME', 'issn_cast_from_ean13' 3272LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; 3273CREATE FUNCTION isbn(ean13) 3274RETURNS isbn 3275AS 'MODULE_PATHNAME', 'isbn_cast_from_ean13' 3276LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; 3277CREATE FUNCTION ismn(ean13) 3278RETURNS ismn 3279AS 'MODULE_PATHNAME', 'ismn_cast_from_ean13' 3280LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; 3281CREATE FUNCTION issn(ean13) 3282RETURNS issn 3283AS 'MODULE_PATHNAME', 'issn_cast_from_ean13' 3284LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; 3285CREATE FUNCTION upc(ean13) 3286RETURNS upc 3287AS 'MODULE_PATHNAME', 'upc_cast_from_ean13' 3288LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; 3289 3290 3291CREATE CAST (ean13 AS isbn13) WITH FUNCTION isbn13(ean13); 3292CREATE CAST (ean13 AS isbn) WITH FUNCTION isbn(ean13); 3293CREATE CAST (ean13 AS ismn13) WITH FUNCTION ismn13(ean13); 3294CREATE CAST (ean13 AS ismn) WITH FUNCTION ismn(ean13); 3295CREATE CAST (ean13 AS issn13) WITH FUNCTION issn13(ean13); 3296CREATE CAST (ean13 AS issn) WITH FUNCTION issn(ean13); 3297CREATE CAST (ean13 AS upc) WITH FUNCTION upc(ean13); 3298 3299CREATE CAST (isbn13 AS ean13) WITHOUT FUNCTION AS ASSIGNMENT; 3300CREATE CAST (isbn AS ean13) WITHOUT FUNCTION AS ASSIGNMENT; 3301CREATE CAST (ismn13 AS ean13) WITHOUT FUNCTION AS ASSIGNMENT; 3302CREATE CAST (ismn AS ean13) WITHOUT FUNCTION AS ASSIGNMENT; 3303CREATE CAST (issn13 AS ean13) WITHOUT FUNCTION AS ASSIGNMENT; 3304CREATE CAST (issn AS ean13) WITHOUT FUNCTION AS ASSIGNMENT; 3305CREATE CAST (upc AS ean13) WITHOUT FUNCTION AS ASSIGNMENT; 3306 3307CREATE CAST (isbn AS isbn13) WITHOUT FUNCTION AS ASSIGNMENT; 3308CREATE CAST (isbn13 AS isbn) WITHOUT FUNCTION AS ASSIGNMENT; 3309CREATE CAST (ismn AS ismn13) WITHOUT FUNCTION AS ASSIGNMENT; 3310CREATE CAST (ismn13 AS ismn) WITHOUT FUNCTION AS ASSIGNMENT; 3311CREATE CAST (issn AS issn13) WITHOUT FUNCTION AS ASSIGNMENT; 3312CREATE CAST (issn13 AS issn) WITHOUT FUNCTION AS ASSIGNMENT; 3313 3314-- 3315-- Validation stuff for lose types: 3316-- 3317CREATE FUNCTION make_valid(ean13) 3318 RETURNS ean13 3319 AS 'MODULE_PATHNAME' 3320 LANGUAGE C 3321 IMMUTABLE STRICT 3322 PARALLEL SAFE; 3323CREATE FUNCTION make_valid(isbn13) 3324 RETURNS isbn13 3325 AS 'MODULE_PATHNAME' 3326 LANGUAGE C 3327 IMMUTABLE STRICT 3328 PARALLEL SAFE; 3329CREATE FUNCTION make_valid(ismn13) 3330 RETURNS ismn13 3331 AS 'MODULE_PATHNAME' 3332 LANGUAGE C 3333 IMMUTABLE STRICT 3334 PARALLEL SAFE; 3335CREATE FUNCTION make_valid(issn13) 3336 RETURNS issn13 3337 AS 'MODULE_PATHNAME' 3338 LANGUAGE C 3339 IMMUTABLE STRICT 3340 PARALLEL SAFE; 3341CREATE FUNCTION make_valid(isbn) 3342 RETURNS isbn 3343 AS 'MODULE_PATHNAME' 3344 LANGUAGE C 3345 IMMUTABLE STRICT 3346 PARALLEL SAFE; 3347CREATE FUNCTION make_valid(ismn) 3348 RETURNS ismn 3349 AS 'MODULE_PATHNAME' 3350 LANGUAGE C 3351 IMMUTABLE STRICT 3352 PARALLEL SAFE; 3353CREATE FUNCTION make_valid(issn) 3354 RETURNS issn 3355 AS 'MODULE_PATHNAME' 3356 LANGUAGE C 3357 IMMUTABLE STRICT 3358 PARALLEL SAFE; 3359CREATE FUNCTION make_valid(upc) 3360 RETURNS upc 3361 AS 'MODULE_PATHNAME' 3362 LANGUAGE C 3363 IMMUTABLE STRICT 3364 PARALLEL SAFE; 3365 3366CREATE FUNCTION is_valid(ean13) 3367 RETURNS boolean 3368 AS 'MODULE_PATHNAME' 3369 LANGUAGE C 3370 IMMUTABLE STRICT 3371 PARALLEL SAFE; 3372CREATE FUNCTION is_valid(isbn13) 3373 RETURNS boolean 3374 AS 'MODULE_PATHNAME' 3375 LANGUAGE C 3376 IMMUTABLE STRICT 3377 PARALLEL SAFE; 3378CREATE FUNCTION is_valid(ismn13) 3379 RETURNS boolean 3380 AS 'MODULE_PATHNAME' 3381 LANGUAGE C 3382 IMMUTABLE STRICT 3383 PARALLEL SAFE; 3384CREATE FUNCTION is_valid(issn13) 3385 RETURNS boolean 3386 AS 'MODULE_PATHNAME' 3387 LANGUAGE C 3388 IMMUTABLE STRICT 3389 PARALLEL SAFE; 3390CREATE FUNCTION is_valid(isbn) 3391 RETURNS boolean 3392 AS 'MODULE_PATHNAME' 3393 LANGUAGE C 3394 IMMUTABLE STRICT 3395 PARALLEL SAFE; 3396CREATE FUNCTION is_valid(ismn) 3397 RETURNS boolean 3398 AS 'MODULE_PATHNAME' 3399 LANGUAGE C 3400 IMMUTABLE STRICT 3401 PARALLEL SAFE; 3402CREATE FUNCTION is_valid(issn) 3403 RETURNS boolean 3404 AS 'MODULE_PATHNAME' 3405 LANGUAGE C 3406 IMMUTABLE STRICT 3407 PARALLEL SAFE; 3408CREATE FUNCTION is_valid(upc) 3409 RETURNS boolean 3410 AS 'MODULE_PATHNAME' 3411 LANGUAGE C 3412 IMMUTABLE STRICT 3413 PARALLEL SAFE; 3414 3415-- 3416-- isn_weak(boolean) - Sets the weak input mode. 3417-- This function is intended for testing use only! 3418-- 3419CREATE FUNCTION isn_weak(boolean) 3420 RETURNS boolean 3421 AS 'MODULE_PATHNAME', 'accept_weak_input' 3422 LANGUAGE C 3423 IMMUTABLE STRICT 3424 PARALLEL RESTRICTED; 3425 3426-- 3427-- isn_weak() - Gets the weak input mode status 3428-- 3429CREATE FUNCTION isn_weak() 3430 RETURNS boolean 3431 AS 'MODULE_PATHNAME', 'weak_input_status' 3432 LANGUAGE C 3433 IMMUTABLE STRICT 3434 PARALLEL RESTRICTED; 3435