diff --git a/contrib/isn/Makefile b/contrib/isn/Makefile index 75c07a8..72be058 100644 --- a/contrib/isn/Makefile +++ b/contrib/isn/Makefile @@ -3,9 +3,11 @@ MODULES = isn EXTENSION = isn -DATA = isn--1.0.sql isn--unpackaged--1.0.sql +DATA = isn--2.0.sql isn--unpackaged--1.0.sql PGFILEDESC = "isn - data types for international product numbering standards" +REGRESS = isn + ifdef USE_PGXS PG_CONFIG = pg_config PGXS := $(shell $(PG_CONFIG) --pgxs) diff --git a/contrib/isn/expected/isn.out b/contrib/isn/expected/isn.out new file mode 100644 index 0000000..954f62b --- /dev/null +++ b/contrib/isn/expected/isn.out @@ -0,0 +1,229 @@ +-- +-- Test ISN extension +-- +CREATE EXTENSION isn; +-- +-- test valid conversions +-- +SELECT '9780123456786'::EAN13, -- old book + '9790123456785'::EAN13, -- music + '9791234567896'::EAN13, -- new book + '9771234567898'::EAN13, -- serial + '0123456789012'::EAN13, -- upc + '1234567890128'::EAN13; + ean13 | ean13 | ean13 | ean13 | ean13 | ean13 +-------------------+-------------------+-----------------+-------------------+-----------------+----------------- + 978-0-12-345678-6 | 979-0-1234-5678-5 | 979-123456789-6 | 977-1234-567-89-8 | 012-345678901-2 | 123-456789012-8 +(1 row) + +SELECT '9780123456786'::ISBN, + '123456789X'::ISBN, + '9780123456786'::ISBN13::ISBN, + '9780123456786'::EAN13::ISBN; + isbn | isbn | isbn | isbn +---------------+---------------+---------------+--------------- + 0-12-345678-9 | 1-234-56789-X | 0-12-345678-9 | 0-12-345678-9 +(1 row) + +SELECT '9780123456786'::ISBN13, + '123456789X'::ISBN13, + '9791234567896'::ISBN13, + '9791234567896'::EAN13::ISBN13; + isbn13 | isbn13 | isbn13 | isbn13 +-------------------+-------------------+-----------------+----------------- + 978-0-12-345678-6 | 978-1-234-56789-7 | 979-123456789-6 | 979-123456789-6 +(1 row) + +SELECT '9790123456785'::ISMN, + '9790123456785'::EAN13::ISMN, + 'M123456785'::ISMN, + 'M-1234-5678-5'::ISMN; + ismn | ismn | ismn | ismn +---------------+---------------+---------------+--------------- + M-1234-5678-5 | M-1234-5678-5 | M-1234-5678-5 | M-1234-5678-5 +(1 row) + +SELECT '9790123456785'::ISMN13, + 'M123456785'::ISMN13, + 'M-1234-5678-5'::ISMN13; + ismn13 | ismn13 | ismn13 +-------------------+-------------------+------------------- + 979-0-1234-5678-5 | 979-0-1234-5678-5 | 979-0-1234-5678-5 +(1 row) + +SELECT '9771234567003'::ISSN, + '12345679'::ISSN; + issn | issn +-----------+----------- + 1234-5679 | 1234-5679 +(1 row) + +SELECT '9771234567003'::ISSN13, + '12345679'::ISSN13, + '9771234567898'::ISSN13, + '9771234567898'::EAN13::ISSN13; + issn13 | issn13 | issn13 | issn13 +-------------------+-------------------+-------------------+------------------- + 977-1234-567-00-3 | 977-1234-567-00-3 | 977-1234-567-89-8 | 977-1234-567-89-8 +(1 row) + +SELECT '0123456789012'::UPC, + '0123456789012'::EAN13::UPC; + upc | upc +--------------+-------------- + 123456789012 | 123456789012 +(1 row) + +-- +-- test invalid checksums +-- +SELECT '1234567890'::ISBN; +ERROR: invalid check digit for ISBN number: "1234567890", should be X +LINE 1: SELECT '1234567890'::ISBN; + ^ +SELECT 'M123456780'::ISMN; +ERROR: invalid check digit for ISMN number: "M123456780", should be 5 +LINE 1: SELECT 'M123456780'::ISMN; + ^ +SELECT '12345670'::ISSN; +ERROR: invalid check digit for ISSN number: "12345670", should be 9 +LINE 1: SELECT '12345670'::ISSN; + ^ +SELECT '9780123456780'::ISBN; +ERROR: invalid check digit for ISBN number: "9780123456780", should be 6 +LINE 1: SELECT '9780123456780'::ISBN; + ^ +SELECT '9791234567890'::ISBN13; +ERROR: invalid check digit for ISBN13 number: "9791234567890", should be 6 +LINE 1: SELECT '9791234567890'::ISBN13; + ^ +SELECT '0123456789010'::UPC; +ERROR: invalid check digit for UPC number: "0123456789010", should be 2 +LINE 1: SELECT '0123456789010'::UPC; + ^ +SELECT '1234567890120'::EAN13; +ERROR: invalid check digit for EAN13 number: "1234567890120", should be 8 +LINE 1: SELECT '1234567890120'::EAN13; + ^ +-- +-- test invalid conversions +-- +SELECT '9790123456785'::ISBN; -- not a book +ERROR: cannot cast ISMN to ISBN for number: "9790123456785" +LINE 1: SELECT '9790123456785'::ISBN; + ^ +SELECT '9791234567896'::ISBN; -- not an old book +ERROR: cannot cast ISBN13 to ISBN for number: "9791234567896" +LINE 1: SELECT '9791234567896'::ISBN; + ^ +SELECT '9771234567898'::ISBN; -- not a book +ERROR: cannot cast ISSN to ISBN for number: "9771234567898" +LINE 1: SELECT '9771234567898'::ISBN; + ^ +SELECT '9791234567896'::ISBN13::ISBN; -- not a an old book +ERROR: cannot cast EAN13(ISBN13) to ISBN for number: "9791234567896" +SELECT '9791234567896'::EAN13::ISBN; -- not a an old book +ERROR: cannot cast EAN13(ISBN13) to ISBN for number: "9791234567896" +SELECT '0123456789012'::ISBN; -- not a book +ERROR: cannot cast UPC to ISBN for number: "0123456789012" +LINE 1: SELECT '0123456789012'::ISBN; + ^ +SELECT '9790123456785'::ISBN13; -- not a book +ERROR: cannot cast ISMN to ISBN13 for number: "9790123456785" +LINE 1: SELECT '9790123456785'::ISBN13; + ^ +SELECT '9771234567898'::ISBN13; -- not a book +ERROR: cannot cast ISSN to ISBN13 for number: "9771234567898" +LINE 1: SELECT '9771234567898'::ISBN13; + ^ +SELECT '9771234567898'::EAN13::ISBN13; -- not a book +ERROR: cannot cast EAN13(ISSN) to ISBN13 for number: "9771234567898" +SELECT '0123456789012'::ISBN13; -- not a book +ERROR: cannot cast UPC to ISBN13 for number: "0123456789012" +LINE 1: SELECT '0123456789012'::ISBN13; + ^ +SELECT '9780123456786'::ISMN; -- not music +ERROR: cannot cast ISBN to ISMN for number: "9780123456786" +LINE 1: SELECT '9780123456786'::ISMN; + ^ +SELECT '9771234567898'::ISMN; -- not music +ERROR: cannot cast ISSN to ISMN for number: "9771234567898" +LINE 1: SELECT '9771234567898'::ISMN; + ^ +SELECT '9791234567896'::ISMN; -- not music +ERROR: cannot cast ISBN13 to ISMN for number: "9791234567896" +LINE 1: SELECT '9791234567896'::ISMN; + ^ +SELECT '0123456789012'::ISMN; -- not music +ERROR: cannot cast UPC to ISMN for number: "0123456789012" +LINE 1: SELECT '0123456789012'::ISMN; + ^ +SELECT '9780123456786'::ISSN; -- not serial +ERROR: cannot cast ISBN to ISSN for number: "9780123456786" +LINE 1: SELECT '9780123456786'::ISSN; + ^ +SELECT '9790123456785'::ISSN; -- not serial +ERROR: cannot cast ISMN to ISSN for number: "9790123456785" +LINE 1: SELECT '9790123456785'::ISSN; + ^ +SELECT '9791234567896'::ISSN; -- not serial +ERROR: cannot cast ISBN13 to ISSN for number: "9791234567896" +LINE 1: SELECT '9791234567896'::ISSN; + ^ +SELECT '0123456789012'::ISSN; -- not serial +ERROR: cannot cast UPC to ISSN for number: "0123456789012" +LINE 1: SELECT '0123456789012'::ISSN; + ^ +SELECT '9780123456786'::UPC; -- not a product +ERROR: cannot cast ISBN to UPC for number: "9780123456786" +LINE 1: SELECT '9780123456786'::UPC; + ^ +SELECT '9771234567898'::UPC; -- not a product +ERROR: cannot cast ISSN to UPC for number: "9771234567898" +LINE 1: SELECT '9771234567898'::UPC; + ^ +SELECT '9790123456785'::UPC; -- not a product +ERROR: cannot cast ISMN to UPC for number: "9790123456785" +LINE 1: SELECT '9790123456785'::UPC; + ^ +SELECT '9791234567896'::UPC; -- not a product +ERROR: cannot cast ISBN13 to UPC for number: "9791234567896" +LINE 1: SELECT '9791234567896'::UPC; + ^ +SELECT '0123456789012'::UPC; -- not a product + upc +-------------- + 123456789012 +(1 row) + +SELECT 'postgresql...'::EAN13; +ERROR: invalid input syntax for EAN13 number: "postgresql..." +LINE 1: SELECT 'postgresql...'::EAN13; + ^ +SELECT 'postgresql...'::ISBN; +ERROR: invalid input syntax for ISBN number: "postgresql..." +LINE 1: SELECT 'postgresql...'::ISBN; + ^ +SELECT 9780123456786::EAN13; +ERROR: cannot cast type bigint to ean13 +LINE 1: SELECT 9780123456786::EAN13; + ^ +SELECT 9780123456786::ISBN; +ERROR: cannot cast type bigint to isbn +LINE 1: SELECT 9780123456786::ISBN; + ^ +-- +-- test some comparisons, must yield true +-- +SELECT '12345679'::ISSN = '9771234567003'::EAN13 AS "ok", + 'M-1234-5678-5'::ISMN = '9790123456785'::EAN13 AS "ok", + '9791234567896'::EAN13 != '123456789X'::ISBN AS "nope"; + ok | ok | nope +----+----+------ + t | t | t +(1 row) + +-- +-- cleanup +-- +DROP EXTENSION isn; diff --git a/contrib/isn/isn--2.0.sql b/contrib/isn/isn--2.0.sql new file mode 100644 index 0000000..93f35c5 --- /dev/null +++ b/contrib/isn/isn--2.0.sql @@ -0,0 +1,3200 @@ +/* contrib/isn/isn--1.0.sql */ + +-- complain if script is sourced in psql, rather than via CREATE EXTENSION +\echo Use "CREATE EXTENSION isn" to load this file. \quit + +-- Example: +-- create table test ( id isbn ); +-- insert into test values('978-0-393-04002-9'); +-- +-- select isbn('978-0-393-04002-9'); +-- select isbn13('0-901690-54-6'); +-- + +-- +-- Input and output functions and data types: +-- +--------------------------------------------------- +CREATE FUNCTION ean13_in(cstring) + RETURNS ean13 + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT; +CREATE FUNCTION ean13_out(ean13) + RETURNS cstring + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT; +CREATE TYPE ean13 ( + INPUT = ean13_in, + OUTPUT = ean13_out, + LIKE = pg_catalog.int8 +); +COMMENT ON TYPE ean13 + IS 'International European Article Number (EAN13)'; + +CREATE FUNCTION isbn13_in(cstring) + RETURNS isbn13 + AS 'MODULE_PATHNAME', 'isbn13_in' + LANGUAGE C + IMMUTABLE STRICT; +CREATE FUNCTION ean13_out(isbn13) + RETURNS cstring + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT; +CREATE TYPE isbn13 ( + INPUT = isbn13_in, + OUTPUT = ean13_out, + LIKE = pg_catalog.int8 +); +COMMENT ON TYPE isbn13 + IS 'International Standard Book Number 13 (ISBN13)'; + +CREATE FUNCTION ismn13_in(cstring) + RETURNS ismn13 + AS 'MODULE_PATHNAME', 'ismn_in' + LANGUAGE C + IMMUTABLE STRICT; +CREATE FUNCTION ean13_out(ismn13) + RETURNS cstring + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT; +CREATE TYPE ismn13 ( + INPUT = ismn13_in, + OUTPUT = ean13_out, + LIKE = pg_catalog.int8 +); +COMMENT ON TYPE ismn13 + IS 'International Standard Music Number 13 (ISMN13)'; + +CREATE FUNCTION issn13_in(cstring) + RETURNS issn13 + AS 'MODULE_PATHNAME', 'issn_in' + LANGUAGE C + IMMUTABLE STRICT; +CREATE FUNCTION ean13_out(issn13) + RETURNS cstring + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT; +CREATE TYPE issn13 ( + INPUT = issn13_in, + OUTPUT = ean13_out, + LIKE = pg_catalog.int8 +); +COMMENT ON TYPE issn13 + IS 'International Standard Serial Number 13 (ISSN13)'; + +-- Short format: + +CREATE FUNCTION isbn_in(cstring) + RETURNS isbn + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT; +CREATE FUNCTION isn_out(isbn) + RETURNS cstring + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT; +CREATE TYPE isbn ( + INPUT = isbn_in, + OUTPUT = isn_out, + LIKE = pg_catalog.int8 +); +COMMENT ON TYPE isbn + IS 'International Standard Book Number (ISBN)'; + +CREATE FUNCTION ismn_in(cstring) + RETURNS ismn + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT; +CREATE FUNCTION isn_out(ismn) + RETURNS cstring + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT; +CREATE TYPE ismn ( + INPUT = ismn_in, + OUTPUT = isn_out, + LIKE = pg_catalog.int8 +); +COMMENT ON TYPE ismn + IS 'International Standard Music Number (ISMN)'; + +CREATE FUNCTION issn_in(cstring) + RETURNS issn + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT; +CREATE FUNCTION isn_out(issn) + RETURNS cstring + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT; +CREATE TYPE issn ( + INPUT = issn_in, + OUTPUT = isn_out, + LIKE = pg_catalog.int8 +); +COMMENT ON TYPE issn + IS 'International Standard Serial Number (ISSN)'; + +CREATE FUNCTION upc_in(cstring) + RETURNS upc + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT; +CREATE FUNCTION isn_out(upc) + RETURNS cstring + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT; +CREATE TYPE upc ( + INPUT = upc_in, + OUTPUT = isn_out, + LIKE = pg_catalog.int8 +); +COMMENT ON TYPE upc + IS 'Universal Product Code (UPC)'; + +-- +-- Operator functions: +-- +--------------------------------------------------- +-- EAN13: +CREATE FUNCTION isnlt(ean13, ean13) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnle(ean13, ean13) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isneq(ean13, ean13) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnge(ean13, ean13) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isngt(ean13, ean13) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnne(ean13, ean13) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +CREATE FUNCTION isnlt(ean13, isbn13) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnle(ean13, isbn13) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isneq(ean13, isbn13) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnge(ean13, isbn13) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isngt(ean13, isbn13) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnne(ean13, isbn13) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +CREATE FUNCTION isnlt(ean13, ismn13) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnle(ean13, ismn13) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isneq(ean13, ismn13) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnge(ean13, ismn13) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isngt(ean13, ismn13) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnne(ean13, ismn13) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +CREATE FUNCTION isnlt(ean13, issn13) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnle(ean13, issn13) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isneq(ean13, issn13) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnge(ean13, issn13) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isngt(ean13, issn13) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnne(ean13, issn13) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +CREATE FUNCTION isnlt(ean13, isbn) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnle(ean13, isbn) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isneq(ean13, isbn) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnge(ean13, isbn) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isngt(ean13, isbn) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnne(ean13, isbn) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +CREATE FUNCTION isnlt(ean13, ismn) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnle(ean13, ismn) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isneq(ean13, ismn) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnge(ean13, ismn) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isngt(ean13, ismn) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnne(ean13, ismn) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +CREATE FUNCTION isnlt(ean13, issn) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnle(ean13, issn) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isneq(ean13, issn) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnge(ean13, issn) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isngt(ean13, issn) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnne(ean13, issn) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +CREATE FUNCTION isnlt(ean13, upc) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnle(ean13, upc) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isneq(ean13, upc) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnge(ean13, upc) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isngt(ean13, upc) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnne(ean13, upc) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +--------------------------------------------------- +-- ISBN13: +CREATE FUNCTION isnlt(isbn13, isbn13) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnle(isbn13, isbn13) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isneq(isbn13, isbn13) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnge(isbn13, isbn13) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isngt(isbn13, isbn13) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnne(isbn13, isbn13) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +CREATE FUNCTION isnlt(isbn13, isbn) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnle(isbn13, isbn) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isneq(isbn13, isbn) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnge(isbn13, isbn) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isngt(isbn13, isbn) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnne(isbn13, isbn) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +CREATE FUNCTION isnlt(isbn13, ean13) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnle(isbn13, ean13) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isneq(isbn13, ean13) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnge(isbn13, ean13) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isngt(isbn13, ean13) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnne(isbn13, ean13) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +--------------------------------------------------- +-- ISBN: +CREATE FUNCTION isnlt(isbn, isbn) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnle(isbn, isbn) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isneq(isbn, isbn) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnge(isbn, isbn) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isngt(isbn, isbn) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnne(isbn, isbn) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +CREATE FUNCTION isnlt(isbn, isbn13) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnle(isbn, isbn13) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isneq(isbn, isbn13) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnge(isbn, isbn13) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isngt(isbn, isbn13) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnne(isbn, isbn13) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +CREATE FUNCTION isnlt(isbn, ean13) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnle(isbn, ean13) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isneq(isbn, ean13) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnge(isbn, ean13) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isngt(isbn, ean13) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnne(isbn, ean13) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +--------------------------------------------------- +-- ISMN13: +CREATE FUNCTION isnlt(ismn13, ismn13) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnle(ismn13, ismn13) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isneq(ismn13, ismn13) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnge(ismn13, ismn13) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isngt(ismn13, ismn13) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnne(ismn13, ismn13) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +CREATE FUNCTION isnlt(ismn13, ismn) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnle(ismn13, ismn) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isneq(ismn13, ismn) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnge(ismn13, ismn) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isngt(ismn13, ismn) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnne(ismn13, ismn) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +CREATE FUNCTION isnlt(ismn13, ean13) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnle(ismn13, ean13) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isneq(ismn13, ean13) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnge(ismn13, ean13) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isngt(ismn13, ean13) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnne(ismn13, ean13) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +--------------------------------------------------- +-- ISMN: +CREATE FUNCTION isnlt(ismn, ismn) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnle(ismn, ismn) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isneq(ismn, ismn) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnge(ismn, ismn) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isngt(ismn, ismn) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnne(ismn, ismn) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +CREATE FUNCTION isnlt(ismn, ismn13) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnle(ismn, ismn13) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isneq(ismn, ismn13) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnge(ismn, ismn13) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isngt(ismn, ismn13) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnne(ismn, ismn13) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +CREATE FUNCTION isnlt(ismn, ean13) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnle(ismn, ean13) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isneq(ismn, ean13) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnge(ismn, ean13) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isngt(ismn, ean13) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnne(ismn, ean13) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +--------------------------------------------------- +-- ISSN13: +CREATE FUNCTION isnlt(issn13, issn13) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnle(issn13, issn13) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isneq(issn13, issn13) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnge(issn13, issn13) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isngt(issn13, issn13) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnne(issn13, issn13) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +CREATE FUNCTION isnlt(issn13, issn) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnle(issn13, issn) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isneq(issn13, issn) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnge(issn13, issn) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isngt(issn13, issn) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnne(issn13, issn) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +CREATE FUNCTION isnlt(issn13, ean13) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnle(issn13, ean13) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isneq(issn13, ean13) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnge(issn13, ean13) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isngt(issn13, ean13) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnne(issn13, ean13) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +--------------------------------------------------- +-- ISSN: +CREATE FUNCTION isnlt(issn, issn) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnle(issn, issn) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isneq(issn, issn) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnge(issn, issn) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isngt(issn, issn) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnne(issn, issn) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +CREATE FUNCTION isnlt(issn, issn13) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnle(issn, issn13) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isneq(issn, issn13) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnge(issn, issn13) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isngt(issn, issn13) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnne(issn, issn13) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +CREATE FUNCTION isnlt(issn, ean13) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnle(issn, ean13) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isneq(issn, ean13) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnge(issn, ean13) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isngt(issn, ean13) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnne(issn, ean13) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +--------------------------------------------------- +-- UPC: +CREATE FUNCTION isnlt(upc, upc) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnle(upc, upc) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isneq(upc, upc) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnge(upc, upc) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isngt(upc, upc) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnne(upc, upc) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +CREATE FUNCTION isnlt(upc, ean13) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnle(upc, ean13) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isneq(upc, ean13) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnge(upc, ean13) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isngt(upc, ean13) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION isnne(upc, ean13) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +-- +-- Now the operators: +-- + +-- +-- EAN13 operators: +-- +--------------------------------------------------- +CREATE OPERATOR < ( + PROCEDURE = isnlt, + LEFTARG = ean13, + RIGHTARG = ean13, + COMMUTATOR = >, + NEGATOR = >=, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR <= ( + PROCEDURE = isnle, + LEFTARG = ean13, + RIGHTARG = ean13, + COMMUTATOR = >=, + NEGATOR = >, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR = ( + PROCEDURE = isneq, + LEFTARG = ean13, + RIGHTARG = ean13, + COMMUTATOR = =, + NEGATOR = <>, + RESTRICT = eqsel, + JOIN = eqjoinsel, + MERGES, + HASHES); +CREATE OPERATOR >= ( + PROCEDURE = isnge, + LEFTARG = ean13, + RIGHTARG = ean13, + COMMUTATOR = <=, + NEGATOR = <, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel ); +CREATE OPERATOR > ( + PROCEDURE = isngt, + LEFTARG = ean13, + RIGHTARG = ean13, + COMMUTATOR = <, + NEGATOR = <=, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel ); +CREATE OPERATOR <> ( + PROCEDURE = isnne, + LEFTARG = ean13, + RIGHTARG = ean13, + COMMUTATOR = <>, + NEGATOR = =, + RESTRICT = neqsel, + JOIN = neqjoinsel); + +CREATE OPERATOR < ( + PROCEDURE = isnlt, + LEFTARG = ean13, + RIGHTARG = isbn13, + COMMUTATOR = >, + NEGATOR = >=, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR <= ( + PROCEDURE = isnle, + LEFTARG = ean13, + RIGHTARG = isbn13, + COMMUTATOR = >=, + NEGATOR = >, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR = ( + PROCEDURE = isneq, + LEFTARG = ean13, + RIGHTARG = isbn13, + COMMUTATOR = =, + NEGATOR = <>, + RESTRICT = eqsel, + JOIN = eqjoinsel, + MERGES, + HASHES); +CREATE OPERATOR >= ( + PROCEDURE = isnge, + LEFTARG = ean13, + RIGHTARG = isbn13, + COMMUTATOR = <=, + NEGATOR = <, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel ); +CREATE OPERATOR > ( + PROCEDURE = isngt, + LEFTARG = ean13, + RIGHTARG = isbn13, + COMMUTATOR = <, + NEGATOR = <=, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel ); +CREATE OPERATOR <> ( + PROCEDURE = isnne, + LEFTARG = ean13, + RIGHTARG = isbn13, + COMMUTATOR = <>, + NEGATOR = =, + RESTRICT = neqsel, + JOIN = neqjoinsel); + +CREATE OPERATOR < ( + PROCEDURE = isnlt, + LEFTARG = isbn13, + RIGHTARG = ean13, + COMMUTATOR = >, + NEGATOR = >=, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR <= ( + PROCEDURE = isnle, + LEFTARG = isbn13, + RIGHTARG = ean13, + COMMUTATOR = >=, + NEGATOR = >, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR = ( + PROCEDURE = isneq, + LEFTARG = isbn13, + RIGHTARG = ean13, + COMMUTATOR = =, + NEGATOR = <>, + RESTRICT = eqsel, + JOIN = eqjoinsel, + MERGES, + HASHES); +CREATE OPERATOR >= ( + PROCEDURE = isnge, + LEFTARG = isbn13, + RIGHTARG = ean13, + COMMUTATOR = <=, + NEGATOR = <, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel ); +CREATE OPERATOR > ( + PROCEDURE = isngt, + LEFTARG = isbn13, + RIGHTARG = ean13, + COMMUTATOR = <, + NEGATOR = <=, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel ); +CREATE OPERATOR <> ( + PROCEDURE = isnne, + LEFTARG = isbn13, + RIGHTARG = ean13, + COMMUTATOR = <>, + NEGATOR = =, + RESTRICT = neqsel, + JOIN = neqjoinsel); + +CREATE OPERATOR < ( + PROCEDURE = isnlt, + LEFTARG = ean13, + RIGHTARG = ismn13, + COMMUTATOR = >, + NEGATOR = >=, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR <= ( + PROCEDURE = isnle, + LEFTARG = ean13, + RIGHTARG = ismn13, + COMMUTATOR = >=, + NEGATOR = >, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR = ( + PROCEDURE = isneq, + LEFTARG = ean13, + RIGHTARG = ismn13, + COMMUTATOR = =, + NEGATOR = <>, + RESTRICT = eqsel, + JOIN = eqjoinsel, + MERGES, + HASHES); +CREATE OPERATOR >= ( + PROCEDURE = isnge, + LEFTARG = ean13, + RIGHTARG = ismn13, + COMMUTATOR = <=, + NEGATOR = <, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel); +CREATE OPERATOR > ( + PROCEDURE = isngt, + LEFTARG = ean13, + RIGHTARG = ismn13, + COMMUTATOR = <, + NEGATOR = <=, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel); +CREATE OPERATOR <> ( + PROCEDURE = isnne, + LEFTARG = ean13, + RIGHTARG = ismn13, + COMMUTATOR = <>, + NEGATOR = =, + RESTRICT = neqsel, + JOIN = neqjoinsel); + +CREATE OPERATOR < ( + PROCEDURE = isnlt, + LEFTARG = ismn13, + RIGHTARG = ean13, + COMMUTATOR = >, + NEGATOR = >=, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR <= ( + PROCEDURE = isnle, + LEFTARG = ismn13, + RIGHTARG = ean13, + COMMUTATOR = >=, + NEGATOR = >, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR = ( + PROCEDURE = isneq, + LEFTARG = ismn13, + RIGHTARG = ean13, + COMMUTATOR = =, + NEGATOR = <>, + RESTRICT = eqsel, + JOIN = eqjoinsel, + MERGES, + HASHES); +CREATE OPERATOR >= ( + PROCEDURE = isnge, + LEFTARG = ismn13, + RIGHTARG = ean13, + COMMUTATOR = <=, + NEGATOR = <, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel ); +CREATE OPERATOR > ( + PROCEDURE = isngt, + LEFTARG = ismn13, + RIGHTARG = ean13, + COMMUTATOR = <, + NEGATOR = <=, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel ); +CREATE OPERATOR <> ( + PROCEDURE = isnne, + LEFTARG = ismn13, + RIGHTARG = ean13, + COMMUTATOR = <>, + NEGATOR = =, + RESTRICT = neqsel, + JOIN = neqjoinsel); + +CREATE OPERATOR < ( + PROCEDURE = isnlt, + LEFTARG = ean13, + RIGHTARG = issn13, + COMMUTATOR = >, + NEGATOR = >=, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR <= ( + PROCEDURE = isnle, + LEFTARG = ean13, + RIGHTARG = issn13, + COMMUTATOR = >=, + NEGATOR = >, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR = ( + PROCEDURE = isneq, + LEFTARG = ean13, + RIGHTARG = issn13, + COMMUTATOR = =, + NEGATOR = <>, + RESTRICT = eqsel, + JOIN = eqjoinsel, + MERGES, + HASHES); +CREATE OPERATOR >= ( + PROCEDURE = isnge, + LEFTARG = ean13, + RIGHTARG = issn13, + COMMUTATOR = <=, + NEGATOR = <, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel); +CREATE OPERATOR > ( + PROCEDURE = isngt, + LEFTARG = ean13, + RIGHTARG = issn13, + COMMUTATOR = <, + NEGATOR = <=, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel); +CREATE OPERATOR <> ( + PROCEDURE = isnne, + LEFTARG = ean13, + RIGHTARG = issn13, + COMMUTATOR = <>, + NEGATOR = =, + RESTRICT = neqsel, + JOIN = neqjoinsel); + +CREATE OPERATOR < ( + PROCEDURE = isnlt, + LEFTARG = ean13, + RIGHTARG = isbn, + COMMUTATOR = >, + NEGATOR = >=, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR <= ( + PROCEDURE = isnle, + LEFTARG = ean13, + RIGHTARG = isbn, + COMMUTATOR = >=, + NEGATOR = >, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR = ( + PROCEDURE = isneq, + LEFTARG = ean13, + RIGHTARG = isbn, + COMMUTATOR = =, + NEGATOR = <>, + RESTRICT = eqsel, + JOIN = eqjoinsel, + MERGES, + HASHES); +CREATE OPERATOR >= ( + PROCEDURE = isnge, + LEFTARG = ean13, + RIGHTARG = isbn, + COMMUTATOR = <=, + NEGATOR = <, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel); +CREATE OPERATOR > ( + PROCEDURE = isngt, + LEFTARG = ean13, + RIGHTARG = isbn, + COMMUTATOR = <, + NEGATOR = <=, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel); +CREATE OPERATOR <> ( + PROCEDURE = isnne, + LEFTARG = ean13, + RIGHTARG = isbn, + COMMUTATOR = <>, + NEGATOR = =, + RESTRICT = neqsel, + JOIN = neqjoinsel); + +CREATE OPERATOR < ( + PROCEDURE = isnlt, + LEFTARG = ean13, + RIGHTARG = ismn, + COMMUTATOR = >, + NEGATOR = >=, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR <= ( + PROCEDURE = isnle, + LEFTARG = ean13, + RIGHTARG = ismn, + COMMUTATOR = >=, + NEGATOR = >, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR = ( + PROCEDURE = isneq, + LEFTARG = ean13, + RIGHTARG = ismn, + COMMUTATOR = =, + NEGATOR = <>, + RESTRICT = eqsel, + JOIN = eqjoinsel, + MERGES, + HASHES); +CREATE OPERATOR >= ( + PROCEDURE = isnge, + LEFTARG = ean13, + RIGHTARG = ismn, + COMMUTATOR = <=, + NEGATOR = <, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel); +CREATE OPERATOR > ( + PROCEDURE = isngt, + LEFTARG = ean13, + RIGHTARG = ismn, + COMMUTATOR = <, + NEGATOR = <=, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel); +CREATE OPERATOR <> ( + PROCEDURE = isnne, + LEFTARG = ean13, + RIGHTARG = ismn, + COMMUTATOR = <>, + NEGATOR = =, + RESTRICT = neqsel, + JOIN = neqjoinsel); + +CREATE OPERATOR < ( + PROCEDURE = isnlt, + LEFTARG = ean13, + RIGHTARG = issn, + COMMUTATOR = >, + NEGATOR = >=, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR <= ( + PROCEDURE = isnle, + LEFTARG = ean13, + RIGHTARG = issn, + COMMUTATOR = >=, + NEGATOR = >, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR = ( + PROCEDURE = isneq, + LEFTARG = ean13, + RIGHTARG = issn, + COMMUTATOR = =, + NEGATOR = <>, + RESTRICT = eqsel, + JOIN = eqjoinsel, + MERGES, + HASHES); +CREATE OPERATOR >= ( + PROCEDURE = isnge, + LEFTARG = ean13, + RIGHTARG = issn, + COMMUTATOR = <=, + NEGATOR = <, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel); +CREATE OPERATOR > ( + PROCEDURE = isngt, + LEFTARG = ean13, + RIGHTARG = issn, + COMMUTATOR = <, + NEGATOR = <=, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel); +CREATE OPERATOR <> ( + PROCEDURE = isnne, + LEFTARG = ean13, + RIGHTARG = issn, + COMMUTATOR = <>, + NEGATOR = =, + RESTRICT = neqsel, + JOIN = neqjoinsel); + +CREATE OPERATOR < ( + PROCEDURE = isnlt, + LEFTARG = ean13, + RIGHTARG = upc, + COMMUTATOR = >, + NEGATOR = >=, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR <= ( + PROCEDURE = isnle, + LEFTARG = ean13, + RIGHTARG = upc, + COMMUTATOR = >=, + NEGATOR = >, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR = ( + PROCEDURE = isneq, + LEFTARG = ean13, + RIGHTARG = upc, + COMMUTATOR = =, + NEGATOR = <>, + RESTRICT = eqsel, + JOIN = eqjoinsel, + MERGES, + HASHES); +CREATE OPERATOR >= ( + PROCEDURE = isnge, + LEFTARG = ean13, + RIGHTARG = upc, + COMMUTATOR = <=, + NEGATOR = <, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel); +CREATE OPERATOR > ( + PROCEDURE = isngt, + LEFTARG = ean13, + RIGHTARG = upc, + COMMUTATOR = <, + NEGATOR = <=, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel); +CREATE OPERATOR <> ( + PROCEDURE = isnne, + LEFTARG = ean13, + RIGHTARG = upc, + COMMUTATOR = <>, + NEGATOR = =, + RESTRICT = neqsel, + JOIN = neqjoinsel); + +-- +-- ISBN13 operators: +-- +--------------------------------------------------- +CREATE OPERATOR < ( + PROCEDURE = isnlt, + LEFTARG = isbn13, + RIGHTARG = isbn13, + COMMUTATOR = >, + NEGATOR = >=, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR <= ( + PROCEDURE = isnle, + LEFTARG = isbn13, + RIGHTARG = isbn13, + COMMUTATOR = >=, + NEGATOR = >, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR = ( + PROCEDURE = isneq, + LEFTARG = isbn13, + RIGHTARG = isbn13, + COMMUTATOR = =, + NEGATOR = <>, + RESTRICT = eqsel, + JOIN = eqjoinsel, + MERGES, + HASHES); +CREATE OPERATOR >= ( + PROCEDURE = isnge, + LEFTARG = isbn13, + RIGHTARG = isbn13, + COMMUTATOR = <=, + NEGATOR = <, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel ); +CREATE OPERATOR > ( + PROCEDURE = isngt, + LEFTARG = isbn13, + RIGHTARG = isbn13, + COMMUTATOR = <, + NEGATOR = <=, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel ); +CREATE OPERATOR <> ( + PROCEDURE = isnne, + LEFTARG = isbn13, + RIGHTARG = isbn13, + COMMUTATOR = <>, + NEGATOR = =, + RESTRICT = neqsel, + JOIN = neqjoinsel); + +CREATE OPERATOR < ( + PROCEDURE = isnlt, + LEFTARG = isbn13, + RIGHTARG = isbn, + COMMUTATOR = >, + NEGATOR = >=, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR <= ( + PROCEDURE = isnle, + LEFTARG = isbn13, + RIGHTARG = isbn, + COMMUTATOR = >=, + NEGATOR = >, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR = ( + PROCEDURE = isneq, + LEFTARG = isbn13, + RIGHTARG = isbn, + COMMUTATOR = =, + NEGATOR = <>, + RESTRICT = eqsel, + JOIN = eqjoinsel, + MERGES, + HASHES); +CREATE OPERATOR >= ( + PROCEDURE = isnge, + LEFTARG = isbn13, + RIGHTARG = isbn, + COMMUTATOR = <=, + NEGATOR = <, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel ); +CREATE OPERATOR > ( + PROCEDURE = isngt, + LEFTARG = isbn13, + RIGHTARG = isbn, + COMMUTATOR = <, + NEGATOR = <=, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel ); +CREATE OPERATOR <> ( + PROCEDURE = isnne, + LEFTARG = isbn13, + RIGHTARG = isbn, + COMMUTATOR = <>, + NEGATOR = =, + RESTRICT = neqsel, + JOIN = neqjoinsel); + +-- +-- ISBN operators: +-- +--------------------------------------------------- +CREATE OPERATOR < ( + PROCEDURE = isnlt, + LEFTARG = isbn, + RIGHTARG = isbn, + COMMUTATOR = >, + NEGATOR = >=, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR <= ( + PROCEDURE = isnle, + LEFTARG = isbn, + RIGHTARG = isbn, + COMMUTATOR = >=, + NEGATOR = >, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR = ( + PROCEDURE = isneq, + LEFTARG = isbn, + RIGHTARG = isbn, + COMMUTATOR = =, + NEGATOR = <>, + RESTRICT = eqsel, + JOIN = eqjoinsel, + MERGES, + HASHES); +CREATE OPERATOR >= ( + PROCEDURE = isnge, + LEFTARG = isbn, + RIGHTARG = isbn, + COMMUTATOR = <=, + NEGATOR = <, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel ); +CREATE OPERATOR > ( + PROCEDURE = isngt, + LEFTARG = isbn, + RIGHTARG = isbn, + COMMUTATOR = <, + NEGATOR = <=, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel ); +CREATE OPERATOR <> ( + PROCEDURE = isnne, + LEFTARG = isbn, + RIGHTARG = isbn, + COMMUTATOR = <>, + NEGATOR = =, + RESTRICT = neqsel, + JOIN = neqjoinsel); + +CREATE OPERATOR < ( + PROCEDURE = isnlt, + LEFTARG = isbn, + RIGHTARG = isbn13, + COMMUTATOR = >, + NEGATOR = >=, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR <= ( + PROCEDURE = isnle, + LEFTARG = isbn, + RIGHTARG = isbn13, + COMMUTATOR = >=, + NEGATOR = >, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR = ( + PROCEDURE = isneq, + LEFTARG = isbn, + RIGHTARG = isbn13, + COMMUTATOR = =, + NEGATOR = <>, + RESTRICT = eqsel, + JOIN = eqjoinsel, + MERGES, + HASHES); +CREATE OPERATOR >= ( + PROCEDURE = isnge, + LEFTARG = isbn, + RIGHTARG = isbn13, + COMMUTATOR = <=, + NEGATOR = <, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel ); +CREATE OPERATOR > ( + PROCEDURE = isngt, + LEFTARG = isbn, + RIGHTARG = isbn13, + COMMUTATOR = <, + NEGATOR = <=, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel ); +CREATE OPERATOR <> ( + PROCEDURE = isnne, + LEFTARG = isbn, + RIGHTARG = isbn13, + COMMUTATOR = <>, + NEGATOR = =, + RESTRICT = neqsel, + JOIN = neqjoinsel); + +CREATE OPERATOR < ( + PROCEDURE = isnlt, + LEFTARG = isbn, + RIGHTARG = ean13, + COMMUTATOR = >, + NEGATOR = >=, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR <= ( + PROCEDURE = isnle, + LEFTARG = isbn, + RIGHTARG = ean13, + COMMUTATOR = >=, + NEGATOR = >, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR = ( + PROCEDURE = isneq, + LEFTARG = isbn, + RIGHTARG = ean13, + COMMUTATOR = =, + NEGATOR = <>, + RESTRICT = eqsel, + JOIN = eqjoinsel, + MERGES, + HASHES); +CREATE OPERATOR >= ( + PROCEDURE = isnge, + LEFTARG = isbn, + RIGHTARG = ean13, + COMMUTATOR = <=, + NEGATOR = <, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel ); +CREATE OPERATOR > ( + PROCEDURE = isngt, + LEFTARG = isbn, + RIGHTARG = ean13, + COMMUTATOR = <, + NEGATOR = <=, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel ); +CREATE OPERATOR <> ( + PROCEDURE = isnne, + LEFTARG = isbn, + RIGHTARG = ean13, + COMMUTATOR = <>, + NEGATOR = =, + RESTRICT = neqsel, + JOIN = neqjoinsel); + +-- +-- ISMN13 operators: +-- +--------------------------------------------------- +CREATE OPERATOR < ( + PROCEDURE = isnlt, + LEFTARG = ismn13, + RIGHTARG = ismn13, + COMMUTATOR = >, + NEGATOR = >=, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR <= ( + PROCEDURE = isnle, + LEFTARG = ismn13, + RIGHTARG = ismn13, + COMMUTATOR = >=, + NEGATOR = >, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR = ( + PROCEDURE = isneq, + LEFTARG = ismn13, + RIGHTARG = ismn13, + COMMUTATOR = =, + NEGATOR = <>, + RESTRICT = eqsel, + JOIN = eqjoinsel, + MERGES, + HASHES); +CREATE OPERATOR >= ( + PROCEDURE = isnge, + LEFTARG = ismn13, + RIGHTARG = ismn13, + COMMUTATOR = <=, + NEGATOR = <, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel ); +CREATE OPERATOR > ( + PROCEDURE = isngt, + LEFTARG = ismn13, + RIGHTARG = ismn13, + COMMUTATOR = <, + NEGATOR = <=, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel ); +CREATE OPERATOR <> ( + PROCEDURE = isnne, + LEFTARG = ismn13, + RIGHTARG = ismn13, + COMMUTATOR = <>, + NEGATOR = =, + RESTRICT = neqsel, + JOIN = neqjoinsel); + +CREATE OPERATOR < ( + PROCEDURE = isnlt, + LEFTARG = ismn13, + RIGHTARG = ismn, + COMMUTATOR = >, + NEGATOR = >=, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR <= ( + PROCEDURE = isnle, + LEFTARG = ismn13, + RIGHTARG = ismn, + COMMUTATOR = >=, + NEGATOR = >, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR = ( + PROCEDURE = isneq, + LEFTARG = ismn13, + RIGHTARG = ismn, + COMMUTATOR = =, + NEGATOR = <>, + RESTRICT = eqsel, + JOIN = eqjoinsel, + MERGES, + HASHES); +CREATE OPERATOR >= ( + PROCEDURE = isnge, + LEFTARG = ismn13, + RIGHTARG = ismn, + COMMUTATOR = <=, + NEGATOR = <, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel ); +CREATE OPERATOR > ( + PROCEDURE = isngt, + LEFTARG = ismn13, + RIGHTARG = ismn, + COMMUTATOR = <, + NEGATOR = <=, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel ); +CREATE OPERATOR <> ( + PROCEDURE = isnne, + LEFTARG = ismn13, + RIGHTARG = ismn, + COMMUTATOR = <>, + NEGATOR = =, + RESTRICT = neqsel, + JOIN = neqjoinsel); + +-- +-- ISMN operators: +-- +--------------------------------------------------- +CREATE OPERATOR < ( + PROCEDURE = isnlt, + LEFTARG = ismn, + RIGHTARG = ismn, + COMMUTATOR = >, + NEGATOR = >=, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR <= ( + PROCEDURE = isnle, + LEFTARG = ismn, + RIGHTARG = ismn, + COMMUTATOR = >=, + NEGATOR = >, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR = ( + PROCEDURE = isneq, + LEFTARG = ismn, + RIGHTARG = ismn, + COMMUTATOR = =, + NEGATOR = <>, + RESTRICT = eqsel, + JOIN = eqjoinsel, + MERGES, + HASHES); +CREATE OPERATOR >= ( + PROCEDURE = isnge, + LEFTARG = ismn, + RIGHTARG = ismn, + COMMUTATOR = <=, + NEGATOR = <, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel ); +CREATE OPERATOR > ( + PROCEDURE = isngt, + LEFTARG = ismn, + RIGHTARG = ismn, + COMMUTATOR = <, + NEGATOR = <=, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel ); +CREATE OPERATOR <> ( + PROCEDURE = isnne, + LEFTARG = ismn, + RIGHTARG = ismn, + COMMUTATOR = <>, + NEGATOR = =, + RESTRICT = neqsel, + JOIN = neqjoinsel); + +CREATE OPERATOR < ( + PROCEDURE = isnlt, + LEFTARG = ismn, + RIGHTARG = ismn13, + COMMUTATOR = >, + NEGATOR = >=, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR <= ( + PROCEDURE = isnle, + LEFTARG = ismn, + RIGHTARG = ismn13, + COMMUTATOR = >=, + NEGATOR = >, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR = ( + PROCEDURE = isneq, + LEFTARG = ismn, + RIGHTARG = ismn13, + COMMUTATOR = =, + NEGATOR = <>, + RESTRICT = eqsel, + JOIN = eqjoinsel, + MERGES, + HASHES); +CREATE OPERATOR >= ( + PROCEDURE = isnge, + LEFTARG = ismn, + RIGHTARG = ismn13, + COMMUTATOR = <=, + NEGATOR = <, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel ); +CREATE OPERATOR > ( + PROCEDURE = isngt, + LEFTARG = ismn, + RIGHTARG = ismn13, + COMMUTATOR = <, + NEGATOR = <=, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel ); +CREATE OPERATOR <> ( + PROCEDURE = isnne, + LEFTARG = ismn, + RIGHTARG = ismn13, + COMMUTATOR = <>, + NEGATOR = =, + RESTRICT = neqsel, + JOIN = neqjoinsel); + +CREATE OPERATOR < ( + PROCEDURE = isnlt, + LEFTARG = ismn, + RIGHTARG = ean13, + COMMUTATOR = >, + NEGATOR = >=, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR <= ( + PROCEDURE = isnle, + LEFTARG = ismn, + RIGHTARG = ean13, + COMMUTATOR = >=, + NEGATOR = >, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR = ( + PROCEDURE = isneq, + LEFTARG = ismn, + RIGHTARG = ean13, + COMMUTATOR = =, + NEGATOR = <>, + RESTRICT = eqsel, + JOIN = eqjoinsel, + MERGES, + HASHES); +CREATE OPERATOR >= ( + PROCEDURE = isnge, + LEFTARG = ismn, + RIGHTARG = ean13, + COMMUTATOR = <=, + NEGATOR = <, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel ); +CREATE OPERATOR > ( + PROCEDURE = isngt, + LEFTARG = ismn, + RIGHTARG = ean13, + COMMUTATOR = <, + NEGATOR = <=, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel ); +CREATE OPERATOR <> ( + PROCEDURE = isnne, + LEFTARG = ismn, + RIGHTARG = ean13, + COMMUTATOR = <>, + NEGATOR = =, + RESTRICT = neqsel, + JOIN = neqjoinsel); + +-- +-- ISSN13 operators: +-- +--------------------------------------------------- +CREATE OPERATOR < ( + PROCEDURE = isnlt, + LEFTARG = issn13, + RIGHTARG = issn13, + COMMUTATOR = >, + NEGATOR = >=, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR <= ( + PROCEDURE = isnle, + LEFTARG = issn13, + RIGHTARG = issn13, + COMMUTATOR = >=, + NEGATOR = >, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR = ( + PROCEDURE = isneq, + LEFTARG = issn13, + RIGHTARG = issn13, + COMMUTATOR = =, + NEGATOR = <>, + RESTRICT = eqsel, + JOIN = eqjoinsel, + MERGES, + HASHES); +CREATE OPERATOR >= ( + PROCEDURE = isnge, + LEFTARG = issn13, + RIGHTARG = issn13, + COMMUTATOR = <=, + NEGATOR = <, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel ); +CREATE OPERATOR > ( + PROCEDURE = isngt, + LEFTARG = issn13, + RIGHTARG = issn13, + COMMUTATOR = <, + NEGATOR = <=, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel ); +CREATE OPERATOR <> ( + PROCEDURE = isnne, + LEFTARG = issn13, + RIGHTARG = issn13, + COMMUTATOR = <>, + NEGATOR = =, + RESTRICT = neqsel, + JOIN = neqjoinsel); + +CREATE OPERATOR < ( + PROCEDURE = isnlt, + LEFTARG = issn13, + RIGHTARG = issn, + COMMUTATOR = >, + NEGATOR = >=, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR <= ( + PROCEDURE = isnle, + LEFTARG = issn13, + RIGHTARG = issn, + COMMUTATOR = >=, + NEGATOR = >, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR = ( + PROCEDURE = isneq, + LEFTARG = issn13, + RIGHTARG = issn, + COMMUTATOR = =, + NEGATOR = <>, + RESTRICT = eqsel, + JOIN = eqjoinsel, + MERGES, + HASHES); +CREATE OPERATOR >= ( + PROCEDURE = isnge, + LEFTARG = issn13, + RIGHTARG = issn, + COMMUTATOR = <=, + NEGATOR = <, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel ); +CREATE OPERATOR > ( + PROCEDURE = isngt, + LEFTARG = issn13, + RIGHTARG = issn, + COMMUTATOR = <, + NEGATOR = <=, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel ); +CREATE OPERATOR <> ( + PROCEDURE = isnne, + LEFTARG = issn13, + RIGHTARG = issn, + COMMUTATOR = <>, + NEGATOR = =, + RESTRICT = neqsel, + JOIN = neqjoinsel); + +CREATE OPERATOR < ( + PROCEDURE = isnlt, + LEFTARG = issn13, + RIGHTARG = ean13, + COMMUTATOR = >, + NEGATOR = >=, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR <= ( + PROCEDURE = isnle, + LEFTARG = issn13, + RIGHTARG = ean13, + COMMUTATOR = >=, + NEGATOR = >, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR = ( + PROCEDURE = isneq, + LEFTARG = issn13, + RIGHTARG = ean13, + COMMUTATOR = =, + NEGATOR = <>, + RESTRICT = eqsel, + JOIN = eqjoinsel, + MERGES, + HASHES); +CREATE OPERATOR >= ( + PROCEDURE = isnge, + LEFTARG = issn13, + RIGHTARG = ean13, + COMMUTATOR = <=, + NEGATOR = <, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel ); +CREATE OPERATOR > ( + PROCEDURE = isngt, + LEFTARG = issn13, + RIGHTARG = ean13, + COMMUTATOR = <, + NEGATOR = <=, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel ); +CREATE OPERATOR <> ( + PROCEDURE = isnne, + LEFTARG = issn13, + RIGHTARG = ean13, + COMMUTATOR = <>, + NEGATOR = =, + RESTRICT = neqsel, + JOIN = neqjoinsel); + +-- +-- ISSN operators: +-- +--------------------------------------------------- +CREATE OPERATOR < ( + PROCEDURE = isnlt, + LEFTARG = issn, + RIGHTARG = issn, + COMMUTATOR = >, + NEGATOR = >=, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR <= ( + PROCEDURE = isnle, + LEFTARG = issn, + RIGHTARG = issn, + COMMUTATOR = >=, + NEGATOR = >, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR = ( + PROCEDURE = isneq, + LEFTARG = issn, + RIGHTARG = issn, + COMMUTATOR = =, + NEGATOR = <>, + RESTRICT = eqsel, + JOIN = eqjoinsel, + MERGES, + HASHES); +CREATE OPERATOR >= ( + PROCEDURE = isnge, + LEFTARG = issn, + RIGHTARG = issn, + COMMUTATOR = <=, + NEGATOR = <, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel ); +CREATE OPERATOR > ( + PROCEDURE = isngt, + LEFTARG = issn, + RIGHTARG = issn, + COMMUTATOR = <, + NEGATOR = <=, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel ); +CREATE OPERATOR <> ( + PROCEDURE = isnne, + LEFTARG = issn, + RIGHTARG = issn, + COMMUTATOR = <>, + NEGATOR = =, + RESTRICT = neqsel, + JOIN = neqjoinsel); + +CREATE OPERATOR < ( + PROCEDURE = isnlt, + LEFTARG = issn, + RIGHTARG = issn13, + COMMUTATOR = >, + NEGATOR = >=, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR <= ( + PROCEDURE = isnle, + LEFTARG = issn, + RIGHTARG = issn13, + COMMUTATOR = >=, + NEGATOR = >, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR = ( + PROCEDURE = isneq, + LEFTARG = issn, + RIGHTARG = issn13, + COMMUTATOR = =, + NEGATOR = <>, + RESTRICT = eqsel, + JOIN = eqjoinsel, + MERGES, + HASHES); +CREATE OPERATOR >= ( + PROCEDURE = isnge, + LEFTARG = issn, + RIGHTARG = issn13, + COMMUTATOR = <=, + NEGATOR = <, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel ); +CREATE OPERATOR > ( + PROCEDURE = isngt, + LEFTARG = issn, + RIGHTARG = issn13, + COMMUTATOR = <, + NEGATOR = <=, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel ); +CREATE OPERATOR <> ( + PROCEDURE = isnne, + LEFTARG = issn, + RIGHTARG = issn13, + COMMUTATOR = <>, + NEGATOR = =, + RESTRICT = neqsel, + JOIN = neqjoinsel); + +CREATE OPERATOR < ( + PROCEDURE = isnlt, + LEFTARG = issn, + RIGHTARG = ean13, + COMMUTATOR = >, + NEGATOR = >=, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR <= ( + PROCEDURE = isnle, + LEFTARG = issn, + RIGHTARG = ean13, + COMMUTATOR = >=, + NEGATOR = >, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR = ( + PROCEDURE = isneq, + LEFTARG = issn, + RIGHTARG = ean13, + COMMUTATOR = =, + NEGATOR = <>, + RESTRICT = eqsel, + JOIN = eqjoinsel, + MERGES, + HASHES); +CREATE OPERATOR >= ( + PROCEDURE = isnge, + LEFTARG = issn, + RIGHTARG = ean13, + COMMUTATOR = <=, + NEGATOR = <, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel ); +CREATE OPERATOR > ( + PROCEDURE = isngt, + LEFTARG = issn, + RIGHTARG = ean13, + COMMUTATOR = <, + NEGATOR = <=, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel ); +CREATE OPERATOR <> ( + PROCEDURE = isnne, + LEFTARG = issn, + RIGHTARG = ean13, + COMMUTATOR = <>, + NEGATOR = =, + RESTRICT = neqsel, + JOIN = neqjoinsel); + +-- +-- UPC operators: +-- +--------------------------------------------------- +CREATE OPERATOR < ( + PROCEDURE = isnlt, + LEFTARG = upc, + RIGHTARG = upc, + COMMUTATOR = >, + NEGATOR = >=, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR <= ( + PROCEDURE = isnle, + LEFTARG = upc, + RIGHTARG = upc, + COMMUTATOR = >=, + NEGATOR = >, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR = ( + PROCEDURE = isneq, + LEFTARG = upc, + RIGHTARG = upc, + COMMUTATOR = =, + NEGATOR = <>, + RESTRICT = eqsel, + JOIN = eqjoinsel, + MERGES, + HASHES); +CREATE OPERATOR >= ( + PROCEDURE = isnge, + LEFTARG = upc, + RIGHTARG = upc, + COMMUTATOR = <=, + NEGATOR = <, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel ); +CREATE OPERATOR > ( + PROCEDURE = isngt, + LEFTARG = upc, + RIGHTARG = upc, + COMMUTATOR = <, + NEGATOR = <=, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel ); +CREATE OPERATOR <> ( + PROCEDURE = isnne, + LEFTARG = upc, + RIGHTARG = upc, + COMMUTATOR = <>, + NEGATOR = =, + RESTRICT = neqsel, + JOIN = neqjoinsel); + +CREATE OPERATOR < ( + PROCEDURE = isnlt, + LEFTARG = upc, + RIGHTARG = ean13, + COMMUTATOR = >, + NEGATOR = >=, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR <= ( + PROCEDURE = isnle, + LEFTARG = upc, + RIGHTARG = ean13, + COMMUTATOR = >=, + NEGATOR = >, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel); +CREATE OPERATOR = ( + PROCEDURE = isneq, + LEFTARG = upc, + RIGHTARG = ean13, + COMMUTATOR = =, + NEGATOR = <>, + RESTRICT = eqsel, + JOIN = eqjoinsel, + MERGES, + HASHES); +CREATE OPERATOR >= ( + PROCEDURE = isnge, + LEFTARG = upc, + RIGHTARG = ean13, + COMMUTATOR = <=, + NEGATOR = <, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel ); +CREATE OPERATOR > ( + PROCEDURE = isngt, + LEFTARG = upc, + RIGHTARG = ean13, + COMMUTATOR = <, + NEGATOR = <=, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel ); +CREATE OPERATOR <> ( + PROCEDURE = isnne, + LEFTARG = upc, + RIGHTARG = ean13, + COMMUTATOR = <>, + NEGATOR = =, + RESTRICT = neqsel, + JOIN = neqjoinsel); + +-- +-- Operator families for the various operator classes: +-- +--------------------------------------------------- + +CREATE OPERATOR FAMILY isn_ops USING btree; +CREATE OPERATOR FAMILY isn_ops USING hash; + +-- +-- Operator classes: +-- +--------------------------------------------------- +-- EAN13: +CREATE FUNCTION btean13cmp(ean13, ean13) + RETURNS int4 + AS 'btint8cmp' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +CREATE OPERATOR CLASS ean13_ops DEFAULT + FOR TYPE ean13 USING btree FAMILY isn_ops AS + OPERATOR 1 <, + OPERATOR 2 <=, + OPERATOR 3 =, + OPERATOR 4 >=, + OPERATOR 5 >, + FUNCTION 1 btean13cmp(ean13, ean13); + +CREATE FUNCTION hashean13(ean13) + RETURNS int4 + AS 'hashint8' + LANGUAGE 'internal' IMMUTABLE STRICT; + +CREATE OPERATOR CLASS ean13_ops DEFAULT + FOR TYPE ean13 USING hash FAMILY isn_ops AS + OPERATOR 1 =, + FUNCTION 1 hashean13(ean13); + +-- EAN13 vs other types: +CREATE FUNCTION btean13cmp(ean13, isbn13) + RETURNS int4 + AS 'btint8cmp' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION btean13cmp(ean13, ismn13) + RETURNS int4 + AS 'btint8cmp' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION btean13cmp(ean13, issn13) + RETURNS int4 + AS 'btint8cmp' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION btean13cmp(ean13, isbn) + RETURNS int4 + AS 'btint8cmp' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION btean13cmp(ean13, ismn) + RETURNS int4 + AS 'btint8cmp' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION btean13cmp(ean13, issn) + RETURNS int4 + AS 'btint8cmp' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION btean13cmp(ean13, upc) + RETURNS int4 + AS 'btint8cmp' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +ALTER OPERATOR FAMILY isn_ops USING btree ADD + OPERATOR 1 < (ean13, isbn13), + OPERATOR 1 < (ean13, ismn13), + OPERATOR 1 < (ean13, issn13), + OPERATOR 1 < (ean13, isbn), + OPERATOR 1 < (ean13, ismn), + OPERATOR 1 < (ean13, issn), + OPERATOR 1 < (ean13, upc), + OPERATOR 2 <= (ean13, isbn13), + OPERATOR 2 <= (ean13, ismn13), + OPERATOR 2 <= (ean13, issn13), + OPERATOR 2 <= (ean13, isbn), + OPERATOR 2 <= (ean13, ismn), + OPERATOR 2 <= (ean13, issn), + OPERATOR 2 <= (ean13, upc), + OPERATOR 3 = (ean13, isbn13), + OPERATOR 3 = (ean13, ismn13), + OPERATOR 3 = (ean13, issn13), + OPERATOR 3 = (ean13, isbn), + OPERATOR 3 = (ean13, ismn), + OPERATOR 3 = (ean13, issn), + OPERATOR 3 = (ean13, upc), + OPERATOR 4 >= (ean13, isbn13), + OPERATOR 4 >= (ean13, ismn13), + OPERATOR 4 >= (ean13, issn13), + OPERATOR 4 >= (ean13, isbn), + OPERATOR 4 >= (ean13, ismn), + OPERATOR 4 >= (ean13, issn), + OPERATOR 4 >= (ean13, upc), + OPERATOR 5 > (ean13, isbn13), + OPERATOR 5 > (ean13, ismn13), + OPERATOR 5 > (ean13, issn13), + OPERATOR 5 > (ean13, isbn), + OPERATOR 5 > (ean13, ismn), + OPERATOR 5 > (ean13, issn), + OPERATOR 5 > (ean13, upc), + FUNCTION 1 btean13cmp(ean13, isbn13), + FUNCTION 1 btean13cmp(ean13, ismn13), + FUNCTION 1 btean13cmp(ean13, issn13), + FUNCTION 1 btean13cmp(ean13, isbn), + FUNCTION 1 btean13cmp(ean13, ismn), + FUNCTION 1 btean13cmp(ean13, issn), + FUNCTION 1 btean13cmp(ean13, upc); + +ALTER OPERATOR FAMILY isn_ops USING hash ADD + OPERATOR 1 = (ean13, isbn13), + OPERATOR 1 = (ean13, ismn13), + OPERATOR 1 = (ean13, issn13), + OPERATOR 1 = (ean13, isbn), + OPERATOR 1 = (ean13, ismn), + OPERATOR 1 = (ean13, issn), + OPERATOR 1 = (ean13, upc); + +--------------------------------------------------- +-- ISBN13: +CREATE FUNCTION btisbn13cmp(isbn13, isbn13) + RETURNS int4 + AS 'btint8cmp' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +CREATE OPERATOR CLASS isbn13_ops DEFAULT + FOR TYPE isbn13 USING btree FAMILY isn_ops AS + OPERATOR 1 <, + OPERATOR 2 <=, + OPERATOR 3 =, + OPERATOR 4 >=, + OPERATOR 5 >, + FUNCTION 1 btisbn13cmp(isbn13, isbn13); + +CREATE FUNCTION hashisbn13(isbn13) + RETURNS int4 + AS 'hashint8' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +CREATE OPERATOR CLASS isbn13_ops DEFAULT + FOR TYPE isbn13 USING hash FAMILY isn_ops AS + OPERATOR 1 =, + FUNCTION 1 hashisbn13(isbn13); + +-- ISBN13 vs other types: +CREATE FUNCTION btisbn13cmp(isbn13, ean13) + RETURNS int4 + AS 'btint8cmp' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION btisbn13cmp(isbn13, isbn) + RETURNS int4 + AS 'btint8cmp' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +ALTER OPERATOR FAMILY isn_ops USING btree ADD + OPERATOR 1 < (isbn13, ean13), + OPERATOR 1 < (isbn13, isbn), + OPERATOR 2 <= (isbn13, ean13), + OPERATOR 2 <= (isbn13, isbn), + OPERATOR 3 = (isbn13, ean13), + OPERATOR 3 = (isbn13, isbn), + OPERATOR 4 >= (isbn13, ean13), + OPERATOR 4 >= (isbn13, isbn), + OPERATOR 5 > (isbn13, ean13), + OPERATOR 5 > (isbn13, isbn), + FUNCTION 1 btisbn13cmp(isbn13, ean13), + FUNCTION 1 btisbn13cmp(isbn13, isbn); + +ALTER OPERATOR FAMILY isn_ops USING hash ADD + OPERATOR 1 = (isbn13, ean13), + OPERATOR 1 = (isbn13, isbn); + +--------------------------------------------------- +-- ISBN: +CREATE FUNCTION btisbncmp(isbn, isbn) + RETURNS int4 + AS 'btint8cmp' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +CREATE OPERATOR CLASS isbn_ops DEFAULT + FOR TYPE isbn USING btree FAMILY isn_ops AS + OPERATOR 1 <, + OPERATOR 2 <=, + OPERATOR 3 =, + OPERATOR 4 >=, + OPERATOR 5 >, + FUNCTION 1 btisbncmp(isbn, isbn); + +CREATE FUNCTION hashisbn(isbn) + RETURNS int4 + AS 'hashint8' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +CREATE OPERATOR CLASS isbn_ops DEFAULT + FOR TYPE isbn USING hash FAMILY isn_ops AS + OPERATOR 1 =, + FUNCTION 1 hashisbn(isbn); + +-- ISBN vs other types: +CREATE FUNCTION btisbncmp(isbn, ean13) + RETURNS int4 + AS 'btint8cmp' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION btisbncmp(isbn, isbn13) + RETURNS int4 + AS 'btint8cmp' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +ALTER OPERATOR FAMILY isn_ops USING btree ADD + OPERATOR 1 < (isbn, ean13), + OPERATOR 1 < (isbn, isbn13), + OPERATOR 2 <= (isbn, ean13), + OPERATOR 2 <= (isbn, isbn13), + OPERATOR 3 = (isbn, ean13), + OPERATOR 3 = (isbn, isbn13), + OPERATOR 4 >= (isbn, ean13), + OPERATOR 4 >= (isbn, isbn13), + OPERATOR 5 > (isbn, ean13), + OPERATOR 5 > (isbn, isbn13), + FUNCTION 1 btisbncmp(isbn, ean13), + FUNCTION 1 btisbncmp(isbn, isbn13); + +ALTER OPERATOR FAMILY isn_ops USING hash ADD + OPERATOR 1 = (isbn, ean13), + OPERATOR 1 = (isbn, isbn13); + +--------------------------------------------------- +-- ISMN13: +CREATE FUNCTION btismn13cmp(ismn13, ismn13) + RETURNS int4 + AS 'btint8cmp' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +CREATE OPERATOR CLASS ismn13_ops DEFAULT + FOR TYPE ismn13 USING btree FAMILY isn_ops AS + OPERATOR 1 <, + OPERATOR 2 <=, + OPERATOR 3 =, + OPERATOR 4 >=, + OPERATOR 5 >, + FUNCTION 1 btismn13cmp(ismn13, ismn13); + +CREATE FUNCTION hashismn13(ismn13) + RETURNS int4 + AS 'hashint8' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +CREATE OPERATOR CLASS ismn13_ops DEFAULT + FOR TYPE ismn13 USING hash FAMILY isn_ops AS + OPERATOR 1 =, + FUNCTION 1 hashismn13(ismn13); + +-- ISMN13 vs other types: +CREATE FUNCTION btismn13cmp(ismn13, ean13) + RETURNS int4 + AS 'btint8cmp' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION btismn13cmp(ismn13, ismn) + RETURNS int4 + AS 'btint8cmp' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +ALTER OPERATOR FAMILY isn_ops USING btree ADD + OPERATOR 1 < (ismn13, ean13), + OPERATOR 1 < (ismn13, ismn), + OPERATOR 2 <= (ismn13, ean13), + OPERATOR 2 <= (ismn13, ismn), + OPERATOR 3 = (ismn13, ean13), + OPERATOR 3 = (ismn13, ismn), + OPERATOR 4 >= (ismn13, ean13), + OPERATOR 4 >= (ismn13, ismn), + OPERATOR 5 > (ismn13, ean13), + OPERATOR 5 > (ismn13, ismn), + FUNCTION 1 btismn13cmp(ismn13, ean13), + FUNCTION 1 btismn13cmp(ismn13, ismn); + +ALTER OPERATOR FAMILY isn_ops USING hash ADD + OPERATOR 1 = (ismn13, ean13), + OPERATOR 1 = (ismn13, ismn); + +--------------------------------------------------- +-- ISMN: +CREATE FUNCTION btismncmp(ismn, ismn) + RETURNS int4 + AS 'btint8cmp' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +CREATE OPERATOR CLASS ismn_ops DEFAULT + FOR TYPE ismn USING btree FAMILY isn_ops AS + OPERATOR 1 <, + OPERATOR 2 <=, + OPERATOR 3 =, + OPERATOR 4 >=, + OPERATOR 5 >, + FUNCTION 1 btismncmp(ismn, ismn); + +CREATE FUNCTION hashismn(ismn) + RETURNS int4 + AS 'hashint8' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +CREATE OPERATOR CLASS ismn_ops DEFAULT + FOR TYPE ismn USING hash FAMILY isn_ops AS + OPERATOR 1 =, + FUNCTION 1 hashismn(ismn); + +-- ISMN vs other types: +CREATE FUNCTION btismncmp(ismn, ean13) + RETURNS int4 + AS 'btint8cmp' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION btismncmp(ismn, ismn13) + RETURNS int4 + AS 'btint8cmp' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +ALTER OPERATOR FAMILY isn_ops USING btree ADD + OPERATOR 1 < (ismn, ean13), + OPERATOR 1 < (ismn, ismn13), + OPERATOR 2 <= (ismn, ean13), + OPERATOR 2 <= (ismn, ismn13), + OPERATOR 3 = (ismn, ean13), + OPERATOR 3 = (ismn, ismn13), + OPERATOR 4 >= (ismn, ean13), + OPERATOR 4 >= (ismn, ismn13), + OPERATOR 5 > (ismn, ean13), + OPERATOR 5 > (ismn, ismn13), + FUNCTION 1 btismncmp(ismn, ean13), + FUNCTION 1 btismncmp(ismn, ismn13); + +ALTER OPERATOR FAMILY isn_ops USING hash ADD + OPERATOR 1 = (ismn, ean13), + OPERATOR 1 = (ismn, ismn13); + +--------------------------------------------------- +-- ISSN13: +CREATE FUNCTION btissn13cmp(issn13, issn13) + RETURNS int4 + AS 'btint8cmp' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +CREATE OPERATOR CLASS issn13_ops DEFAULT + FOR TYPE issn13 USING btree FAMILY isn_ops AS + OPERATOR 1 <, + OPERATOR 2 <=, + OPERATOR 3 =, + OPERATOR 4 >=, + OPERATOR 5 >, + FUNCTION 1 btissn13cmp(issn13, issn13); + +CREATE FUNCTION hashissn13(issn13) + RETURNS int4 + AS 'hashint8' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +CREATE OPERATOR CLASS issn13_ops DEFAULT + FOR TYPE issn13 USING hash FAMILY isn_ops AS + OPERATOR 1 =, + FUNCTION 1 hashissn13(issn13); + +-- ISSN13 vs other types: +CREATE FUNCTION btissn13cmp(issn13, ean13) + RETURNS int4 + AS 'btint8cmp' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION btissn13cmp(issn13, issn) + RETURNS int4 + AS 'btint8cmp' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +ALTER OPERATOR FAMILY isn_ops USING btree ADD + OPERATOR 1 < (issn13, ean13), + OPERATOR 1 < (issn13, issn), + OPERATOR 2 <= (issn13, ean13), + OPERATOR 2 <= (issn13, issn), + OPERATOR 3 = (issn13, ean13), + OPERATOR 3 = (issn13, issn), + OPERATOR 4 >= (issn13, ean13), + OPERATOR 4 >= (issn13, issn), + OPERATOR 5 > (issn13, ean13), + OPERATOR 5 > (issn13, issn), + FUNCTION 1 btissn13cmp(issn13, ean13), + FUNCTION 1 btissn13cmp(issn13, issn); + +ALTER OPERATOR FAMILY isn_ops USING hash ADD + OPERATOR 1 = (issn13, ean13), + OPERATOR 1 = (issn13, issn); + +--------------------------------------------------- +-- ISSN: +CREATE FUNCTION btissncmp(issn, issn) + RETURNS int4 + AS 'btint8cmp' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +CREATE OPERATOR CLASS issn_ops DEFAULT + FOR TYPE issn USING btree FAMILY isn_ops AS + OPERATOR 1 <, + OPERATOR 2 <=, + OPERATOR 3 =, + OPERATOR 4 >=, + OPERATOR 5 >, + FUNCTION 1 btissncmp(issn, issn); + +CREATE FUNCTION hashissn(issn) + RETURNS int4 + AS 'hashint8' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +CREATE OPERATOR CLASS issn_ops DEFAULT + FOR TYPE issn USING hash FAMILY isn_ops AS + OPERATOR 1 =, + FUNCTION 1 hashissn(issn); + +-- ISSN vs other types: +CREATE FUNCTION btissncmp(issn, ean13) + RETURNS int4 + AS 'btint8cmp' + LANGUAGE 'internal' + IMMUTABLE STRICT; +CREATE FUNCTION btissncmp(issn, issn13) + RETURNS int4 + AS 'btint8cmp' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +ALTER OPERATOR FAMILY isn_ops USING btree ADD + OPERATOR 1 < (issn, ean13), + OPERATOR 1 < (issn, issn13), + OPERATOR 2 <= (issn, ean13), + OPERATOR 2 <= (issn, issn13), + OPERATOR 3 = (issn, ean13), + OPERATOR 3 = (issn, issn13), + OPERATOR 4 >= (issn, ean13), + OPERATOR 4 >= (issn, issn13), + OPERATOR 5 > (issn, ean13), + OPERATOR 5 > (issn, issn13), + FUNCTION 1 btissncmp(issn, ean13), + FUNCTION 1 btissncmp(issn, issn13); + +ALTER OPERATOR FAMILY isn_ops USING hash ADD + OPERATOR 1 = (issn, ean13), + OPERATOR 1 = (issn, issn13); + +--------------------------------------------------- +-- UPC: +CREATE FUNCTION btupccmp(upc, upc) + RETURNS int4 + AS 'btint8cmp' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +CREATE OPERATOR CLASS upc_ops DEFAULT + FOR TYPE upc USING btree FAMILY isn_ops AS + OPERATOR 1 <, + OPERATOR 2 <=, + OPERATOR 3 =, + OPERATOR 4 >=, + OPERATOR 5 >, + FUNCTION 1 btupccmp(upc, upc); + +CREATE FUNCTION hashupc(upc) + RETURNS int4 + AS 'hashint8' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +CREATE OPERATOR CLASS upc_ops DEFAULT + FOR TYPE upc USING hash FAMILY isn_ops AS + OPERATOR 1 =, + FUNCTION 1 hashupc(upc); + +-- UPC vs other types: +CREATE FUNCTION btupccmp(upc, ean13) + RETURNS int4 + AS 'btint8cmp' + LANGUAGE 'internal' + IMMUTABLE STRICT; + +ALTER OPERATOR FAMILY isn_ops USING btree ADD + OPERATOR 1 < (upc, ean13), + OPERATOR 2 <= (upc, ean13), + OPERATOR 3 = (upc, ean13), + OPERATOR 4 >= (upc, ean13), + OPERATOR 5 > (upc, ean13), + FUNCTION 1 btupccmp(upc, ean13); + +ALTER OPERATOR FAMILY isn_ops USING hash ADD + OPERATOR 1 = (upc, ean13); + +-- +-- Type casts: +-- +--------------------------------------------------- +CREATE FUNCTION isbn13(ean13) +RETURNS isbn13 +AS 'MODULE_PATHNAME', 'isbn13_cast_from_ean13' +LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION ismn13(ean13) +RETURNS ismn13 +AS 'MODULE_PATHNAME', 'ismn_cast_from_ean13' +LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION issn13(ean13) +RETURNS issn13 +AS 'MODULE_PATHNAME', 'issn_cast_from_ean13' +LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION isbn(ean13) +RETURNS isbn +AS 'MODULE_PATHNAME', 'isbn_cast_from_ean13' +LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION isbn(isbn13) +RETURNS isbn +AS 'MODULE_PATHNAME', 'isbn_cast_from_ean13' +LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION ismn(ean13) +RETURNS ismn +AS 'MODULE_PATHNAME', 'ismn_cast_from_ean13' +LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION issn(ean13) +RETURNS issn +AS 'MODULE_PATHNAME', 'issn_cast_from_ean13' +LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION upc(ean13) +RETURNS upc +AS 'MODULE_PATHNAME', 'upc_cast_from_ean13' +LANGUAGE C IMMUTABLE STRICT; + + +CREATE CAST (ean13 AS isbn13) WITH FUNCTION isbn13(ean13); +CREATE CAST (ean13 AS isbn) WITH FUNCTION isbn(ean13); +CREATE CAST (ean13 AS ismn13) WITH FUNCTION ismn13(ean13); +CREATE CAST (ean13 AS ismn) WITH FUNCTION ismn(ean13); +CREATE CAST (ean13 AS issn13) WITH FUNCTION issn13(ean13); +CREATE CAST (ean13 AS issn) WITH FUNCTION issn(ean13); +CREATE CAST (ean13 AS upc) WITH FUNCTION upc(ean13); + +CREATE CAST (isbn13 AS ean13) WITHOUT FUNCTION AS ASSIGNMENT; +CREATE CAST (isbn AS ean13) WITHOUT FUNCTION AS ASSIGNMENT; +CREATE CAST (ismn13 AS ean13) WITHOUT FUNCTION AS ASSIGNMENT; +CREATE CAST (ismn AS ean13) WITHOUT FUNCTION AS ASSIGNMENT; +CREATE CAST (issn13 AS ean13) WITHOUT FUNCTION AS ASSIGNMENT; +CREATE CAST (issn AS ean13) WITHOUT FUNCTION AS ASSIGNMENT; +CREATE CAST (upc AS ean13) WITHOUT FUNCTION AS ASSIGNMENT; + +CREATE CAST (isbn AS isbn13) WITHOUT FUNCTION AS ASSIGNMENT; +CREATE CAST (isbn13 AS isbn) WITH FUNCTION isbn(isbn13); +CREATE CAST (ismn AS ismn13) WITHOUT FUNCTION AS ASSIGNMENT; +CREATE CAST (ismn13 AS ismn) WITHOUT FUNCTION AS ASSIGNMENT; +CREATE CAST (issn AS issn13) WITHOUT FUNCTION AS ASSIGNMENT; +CREATE CAST (issn13 AS issn) WITHOUT FUNCTION AS ASSIGNMENT; + +-- +-- Validation stuff for lose types: +-- +CREATE FUNCTION make_valid(ean13) + RETURNS ean13 + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT; +CREATE FUNCTION make_valid(isbn13) + RETURNS isbn13 + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT; +CREATE FUNCTION make_valid(ismn13) + RETURNS ismn13 + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT; +CREATE FUNCTION make_valid(issn13) + RETURNS issn13 + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT; +CREATE FUNCTION make_valid(isbn) + RETURNS isbn + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT; +CREATE FUNCTION make_valid(ismn) + RETURNS ismn + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT; +CREATE FUNCTION make_valid(issn) + RETURNS issn + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT; +CREATE FUNCTION make_valid(upc) + RETURNS upc + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT; + +CREATE FUNCTION is_valid(ean13) + RETURNS boolean + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT; +CREATE FUNCTION is_valid(isbn13) + RETURNS boolean + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT; +CREATE FUNCTION is_valid(ismn13) + RETURNS boolean + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT; +CREATE FUNCTION is_valid(issn13) + RETURNS boolean + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT; +CREATE FUNCTION is_valid(isbn) + RETURNS boolean + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT; +CREATE FUNCTION is_valid(ismn) + RETURNS boolean + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT; +CREATE FUNCTION is_valid(issn) + RETURNS boolean + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT; +CREATE FUNCTION is_valid(upc) + RETURNS boolean + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT; + +-- +-- isn_weak(boolean) - Sets the weak input mode. +-- This function is intended for testing use only! +-- +CREATE FUNCTION isn_weak(boolean) + RETURNS boolean + AS 'MODULE_PATHNAME', 'accept_weak_input' + LANGUAGE C + IMMUTABLE STRICT; + +-- +-- isn_weak() - Gets the weak input mode status +-- +CREATE FUNCTION isn_weak() + RETURNS boolean + AS 'MODULE_PATHNAME', 'weak_input_status' + LANGUAGE C + IMMUTABLE STRICT; diff --git a/contrib/isn/isn.c b/contrib/isn/isn.c index 4039824..0490814 100644 --- a/contrib/isn/isn.c +++ b/contrib/isn/isn.c @@ -30,10 +30,14 @@ PG_MODULE_MAGIC; enum isn_type { - INVALID, ANY, EAN13, ISBN, ISMN, ISSN, UPC + /* ISBN/ISBN13 are not interchangeable */ + INVALID, ANY, EAN13, ISBN13, ISBN, ISMN, ISSN, UPC }; -static const char *const isn_names[] = {"EAN13/UPC/ISxN", "EAN13/UPC/ISxN", "EAN13", "ISBN", "ISMN", "ISSN", "UPC"}; +static const char *const isn_names[] = { + "EAN13/UPC/ISxN", "EAN13/UPC/ISxN", "EAN13", "ISBN13", + "ISBN", "ISMN", "ISSN", "UPC" +}; static bool g_weak = false; static bool g_initialized = false; @@ -366,7 +370,7 @@ ean2isn(ean13 ean, bool errorOK, ean13 *result, enum isn_type accept) /* find out the data type: */ if (strncmp("978", buf, 3) == 0) - { /* ISBN */ + { /* ISBN or ISBN-13 */ type = ISBN; } else if (strncmp("977", buf, 3) == 0) @@ -379,7 +383,7 @@ ean2isn(ean13 ean, bool errorOK, ean13 *result, enum isn_type accept) } else if (strncmp("979", buf, 3) == 0) { /* ISBN-13 */ - type = ISBN; + type = ISBN13; } else if (*buf == '0') { /* UPC */ @@ -389,7 +393,8 @@ ean2isn(ean13 ean, bool errorOK, ean13 *result, enum isn_type accept) { type = EAN13; } - if (accept != ANY && accept != EAN13 && accept != type) + if (accept != ANY && accept != EAN13 && accept != type && + !(accept == ISBN13 && type == ISBN)) goto eanwrongtype; *result = ret; @@ -571,7 +576,7 @@ ean2string(ean13 ean, bool errorOK, char *result, bool shortType) /* find out what type of hyphenation is needed: */ if (strncmp("978-", result, search) == 0) - { /* ISBN -13 978-range */ + { /* ISBN-13 978-range */ /* The string should be in this form: 978-??000000000-0" */ type = ISBN; TABLE = ISBN_range; @@ -594,7 +599,7 @@ ean2string(ean13 ean, bool errorOK, char *result, bool shortType) else if (strncmp("979-", result, search) == 0) { /* ISBN-13 979-range */ /* The string should be in this form: 979-??000000000-0" */ - type = ISBN; + type = ISBN13; TABLE = ISBN_range_new; TABLE_index = ISBN_index_new; } @@ -640,6 +645,8 @@ okay: case UPC: ean2UPC(result); break; + case ISBN13: + goto eantoobig; default: break; } @@ -804,7 +811,8 @@ string2ean(const char *str, bool errorOK, ean13 *result, /* obtain the real check digit value, validate, and convert to ean13: */ if (accept == EAN13 && type != accept) goto eanwrongtype; - if (accept != ANY && type != EAN13 && type != accept) + if (accept != ANY && type != EAN13 && type != accept && + !(accept == ISBN13 && type == ISBN)) goto eanwrongtype; switch (type) { @@ -816,12 +824,13 @@ string2ean(const char *str, bool errorOK, ean13 *result, else if (strncmp("977", buf + 3, 3) == 0) type = ISSN; else if (strncmp("978", buf + 3, 3) == 0) - type = ISBN; + type = ISBN; /* or ISBN13 */ else if (strncmp("9790", buf + 3, 4) == 0) type = ISMN; else if (strncmp("979", buf + 3, 3) == 0) - type = ISBN; - if (accept != EAN13 && accept != ANY && type != accept) + type = ISBN13; + if (accept != EAN13 && accept != ANY && type != accept && + !(accept == ISBN13 && type == ISBN)) goto eanwrongtype; break; case ISMN: @@ -991,6 +1000,17 @@ isbn_in(PG_FUNCTION_ARGS) PG_RETURN_EAN13(result); } +PG_FUNCTION_INFO_V1(isbn13_in); +Datum +isbn13_in(PG_FUNCTION_ARGS) +{ + const char *str = PG_GETARG_CSTRING(0); + ean13 result; + + (void) string2ean(str, false, &result, ISBN13); + PG_RETURN_EAN13(result); +} + /* ismn_in */ PG_FUNCTION_INFO_V1(ismn_in); @@ -1044,6 +1064,18 @@ isbn_cast_from_ean13(PG_FUNCTION_ARGS) PG_RETURN_EAN13(result); } +PG_FUNCTION_INFO_V1(isbn13_cast_from_ean13); +Datum +isbn13_cast_from_ean13(PG_FUNCTION_ARGS) +{ + ean13 val = PG_GETARG_EAN13(0); + ean13 result; + + (void) ean2isn(val, false, &result, ISBN13); + + PG_RETURN_EAN13(result); +} + PG_FUNCTION_INFO_V1(ismn_cast_from_ean13); Datum ismn_cast_from_ean13(PG_FUNCTION_ARGS) diff --git a/contrib/isn/isn.control b/contrib/isn/isn.control index cf0b2eb..f71f0bb 100644 --- a/contrib/isn/isn.control +++ b/contrib/isn/isn.control @@ -1,5 +1,5 @@ # isn extension comment = 'data types for international product numbering standards' -default_version = '1.0' +default_version = '2.0' module_pathname = '$libdir/isn' relocatable = true diff --git a/contrib/isn/sql/isn.sql b/contrib/isn/sql/isn.sql new file mode 100644 index 0000000..0f7a557 --- /dev/null +++ b/contrib/isn/sql/isn.sql @@ -0,0 +1,104 @@ +-- +-- Test ISN extension +-- + +CREATE EXTENSION isn; + +-- +-- test valid conversions +-- +SELECT '9780123456786'::EAN13, -- old book + '9790123456785'::EAN13, -- music + '9791234567896'::EAN13, -- new book + '9771234567898'::EAN13, -- serial + '0123456789012'::EAN13, -- upc + '1234567890128'::EAN13; + +SELECT '9780123456786'::ISBN, + '123456789X'::ISBN, + '9780123456786'::ISBN13::ISBN, + '9780123456786'::EAN13::ISBN; + +SELECT '9780123456786'::ISBN13, + '123456789X'::ISBN13, + '9791234567896'::ISBN13, + '9791234567896'::EAN13::ISBN13; + +SELECT '9790123456785'::ISMN, + '9790123456785'::EAN13::ISMN, + 'M123456785'::ISMN, + 'M-1234-5678-5'::ISMN; + +SELECT '9790123456785'::ISMN13, + 'M123456785'::ISMN13, + 'M-1234-5678-5'::ISMN13; + +SELECT '9771234567003'::ISSN, + '12345679'::ISSN; + +SELECT '9771234567003'::ISSN13, + '12345679'::ISSN13, + '9771234567898'::ISSN13, + '9771234567898'::EAN13::ISSN13; + +SELECT '0123456789012'::UPC, + '0123456789012'::EAN13::UPC; + +-- +-- test invalid checksums +-- +SELECT '1234567890'::ISBN; +SELECT 'M123456780'::ISMN; +SELECT '12345670'::ISSN; +SELECT '9780123456780'::ISBN; +SELECT '9791234567890'::ISBN13; +SELECT '0123456789010'::UPC; +SELECT '1234567890120'::EAN13; + +-- +-- test invalid conversions +-- +SELECT '9790123456785'::ISBN; -- not a book +SELECT '9791234567896'::ISBN; -- not an old book +SELECT '9771234567898'::ISBN; -- not a book +SELECT '9791234567896'::ISBN13::ISBN; -- not a an old book +SELECT '9791234567896'::EAN13::ISBN; -- not a an old book +SELECT '0123456789012'::ISBN; -- not a book + +SELECT '9790123456785'::ISBN13; -- not a book +SELECT '9771234567898'::ISBN13; -- not a book +SELECT '9771234567898'::EAN13::ISBN13; -- not a book +SELECT '0123456789012'::ISBN13; -- not a book + +SELECT '9780123456786'::ISMN; -- not music +SELECT '9771234567898'::ISMN; -- not music +SELECT '9791234567896'::ISMN; -- not music +SELECT '0123456789012'::ISMN; -- not music + +SELECT '9780123456786'::ISSN; -- not serial +SELECT '9790123456785'::ISSN; -- not serial +SELECT '9791234567896'::ISSN; -- not serial +SELECT '0123456789012'::ISSN; -- not serial + +SELECT '9780123456786'::UPC; -- not a product +SELECT '9771234567898'::UPC; -- not a product +SELECT '9790123456785'::UPC; -- not a product +SELECT '9791234567896'::UPC; -- not a product +SELECT '0123456789012'::UPC; -- not a product + +SELECT 'postgresql...'::EAN13; +SELECT 'postgresql...'::ISBN; +SELECT 9780123456786::EAN13; +SELECT 9780123456786::ISBN; + +-- +-- test some comparisons, must yield true +-- +SELECT '12345679'::ISSN = '9771234567003'::EAN13 AS "ok", + 'M-1234-5678-5'::ISMN = '9790123456785'::EAN13 AS "ok", + '9791234567896'::EAN13 != '123456789X'::ISBN AS "nope"; + +-- +-- cleanup +-- +DROP EXTENSION isn;