granicus.if.org Git - postgresql/blob - contrib/isn/isn--1.0.sql

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