diff options
Diffstat (limited to 'contrib/isn/isn--1.1.sql')
| -rw-r--r-- | contrib/isn/isn--1.1.sql | 3434 |
1 files changed, 3434 insertions, 0 deletions
diff --git a/contrib/isn/isn--1.1.sql b/contrib/isn/isn--1.1.sql new file mode 100644 index 0000000..5206961 --- /dev/null +++ b/contrib/isn/isn--1.1.sql @@ -0,0 +1,3434 @@ +/* contrib/isn/isn--1.1.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 + PARALLEL SAFE; +CREATE FUNCTION ean13_out(ean13) + RETURNS cstring + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT + PARALLEL SAFE; +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', 'isbn_in' + LANGUAGE C + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION ean13_out(isbn13) + RETURNS cstring + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT + PARALLEL SAFE; +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 + PARALLEL SAFE; +CREATE FUNCTION ean13_out(ismn13) + RETURNS cstring + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT + PARALLEL SAFE; +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 + PARALLEL SAFE; +CREATE FUNCTION ean13_out(issn13) + RETURNS cstring + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT + PARALLEL SAFE; +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 + PARALLEL SAFE; +CREATE FUNCTION isn_out(isbn) + RETURNS cstring + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT + PARALLEL SAFE; +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 + PARALLEL SAFE; +CREATE FUNCTION isn_out(ismn) + RETURNS cstring + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT + PARALLEL SAFE; +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 + PARALLEL SAFE; +CREATE FUNCTION isn_out(issn) + RETURNS cstring + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT + PARALLEL SAFE; +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 + PARALLEL SAFE; +CREATE FUNCTION isn_out(upc) + RETURNS cstring + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT + PARALLEL SAFE; +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 + PARALLEL SAFE; +CREATE FUNCTION isnle(ean13, ean13) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isneq(ean13, ean13) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnge(ean13, ean13) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isngt(ean13, ean13) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnne(ean13, ean13) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; + +CREATE FUNCTION isnlt(ean13, isbn13) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnle(ean13, isbn13) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isneq(ean13, isbn13) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnge(ean13, isbn13) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isngt(ean13, isbn13) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnne(ean13, isbn13) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; + +CREATE FUNCTION isnlt(ean13, ismn13) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnle(ean13, ismn13) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isneq(ean13, ismn13) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnge(ean13, ismn13) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isngt(ean13, ismn13) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnne(ean13, ismn13) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; + +CREATE FUNCTION isnlt(ean13, issn13) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnle(ean13, issn13) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isneq(ean13, issn13) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnge(ean13, issn13) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isngt(ean13, issn13) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnne(ean13, issn13) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; + +CREATE FUNCTION isnlt(ean13, isbn) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnle(ean13, isbn) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isneq(ean13, isbn) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnge(ean13, isbn) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isngt(ean13, isbn) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnne(ean13, isbn) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; + +CREATE FUNCTION isnlt(ean13, ismn) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnle(ean13, ismn) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isneq(ean13, ismn) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnge(ean13, ismn) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isngt(ean13, ismn) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnne(ean13, ismn) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; + +CREATE FUNCTION isnlt(ean13, issn) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnle(ean13, issn) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isneq(ean13, issn) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnge(ean13, issn) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isngt(ean13, issn) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnne(ean13, issn) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; + +CREATE FUNCTION isnlt(ean13, upc) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnle(ean13, upc) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isneq(ean13, upc) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnge(ean13, upc) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isngt(ean13, upc) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnne(ean13, upc) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; + +--------------------------------------------------- +-- ISBN13: +CREATE FUNCTION isnlt(isbn13, isbn13) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnle(isbn13, isbn13) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isneq(isbn13, isbn13) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnge(isbn13, isbn13) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isngt(isbn13, isbn13) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnne(isbn13, isbn13) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; + +CREATE FUNCTION isnlt(isbn13, isbn) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnle(isbn13, isbn) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isneq(isbn13, isbn) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnge(isbn13, isbn) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isngt(isbn13, isbn) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnne(isbn13, isbn) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; + +CREATE FUNCTION isnlt(isbn13, ean13) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnle(isbn13, ean13) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isneq(isbn13, ean13) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnge(isbn13, ean13) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isngt(isbn13, ean13) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnne(isbn13, ean13) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; + +--------------------------------------------------- +-- ISBN: +CREATE FUNCTION isnlt(isbn, isbn) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnle(isbn, isbn) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isneq(isbn, isbn) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnge(isbn, isbn) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isngt(isbn, isbn) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnne(isbn, isbn) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; + +CREATE FUNCTION isnlt(isbn, isbn13) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnle(isbn, isbn13) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isneq(isbn, isbn13) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnge(isbn, isbn13) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isngt(isbn, isbn13) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnne(isbn, isbn13) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; + +CREATE FUNCTION isnlt(isbn, ean13) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnle(isbn, ean13) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isneq(isbn, ean13) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnge(isbn, ean13) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isngt(isbn, ean13) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnne(isbn, ean13) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; + +--------------------------------------------------- +-- ISMN13: +CREATE FUNCTION isnlt(ismn13, ismn13) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnle(ismn13, ismn13) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isneq(ismn13, ismn13) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnge(ismn13, ismn13) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isngt(ismn13, ismn13) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnne(ismn13, ismn13) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; + +CREATE FUNCTION isnlt(ismn13, ismn) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnle(ismn13, ismn) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isneq(ismn13, ismn) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnge(ismn13, ismn) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isngt(ismn13, ismn) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnne(ismn13, ismn) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; + +CREATE FUNCTION isnlt(ismn13, ean13) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnle(ismn13, ean13) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isneq(ismn13, ean13) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnge(ismn13, ean13) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isngt(ismn13, ean13) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnne(ismn13, ean13) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; + +--------------------------------------------------- +-- ISMN: +CREATE FUNCTION isnlt(ismn, ismn) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnle(ismn, ismn) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isneq(ismn, ismn) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnge(ismn, ismn) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isngt(ismn, ismn) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnne(ismn, ismn) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; + +CREATE FUNCTION isnlt(ismn, ismn13) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnle(ismn, ismn13) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isneq(ismn, ismn13) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnge(ismn, ismn13) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isngt(ismn, ismn13) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnne(ismn, ismn13) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; + +CREATE FUNCTION isnlt(ismn, ean13) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnle(ismn, ean13) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isneq(ismn, ean13) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnge(ismn, ean13) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isngt(ismn, ean13) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnne(ismn, ean13) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; + +--------------------------------------------------- +-- ISSN13: +CREATE FUNCTION isnlt(issn13, issn13) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnle(issn13, issn13) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isneq(issn13, issn13) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnge(issn13, issn13) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isngt(issn13, issn13) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnne(issn13, issn13) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; + +CREATE FUNCTION isnlt(issn13, issn) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnle(issn13, issn) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isneq(issn13, issn) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnge(issn13, issn) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isngt(issn13, issn) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnne(issn13, issn) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; + +CREATE FUNCTION isnlt(issn13, ean13) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnle(issn13, ean13) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isneq(issn13, ean13) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnge(issn13, ean13) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isngt(issn13, ean13) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnne(issn13, ean13) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; + +--------------------------------------------------- +-- ISSN: +CREATE FUNCTION isnlt(issn, issn) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnle(issn, issn) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isneq(issn, issn) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnge(issn, issn) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isngt(issn, issn) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnne(issn, issn) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; + +CREATE FUNCTION isnlt(issn, issn13) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnle(issn, issn13) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isneq(issn, issn13) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnge(issn, issn13) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isngt(issn, issn13) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnne(issn, issn13) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; + +CREATE FUNCTION isnlt(issn, ean13) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnle(issn, ean13) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isneq(issn, ean13) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnge(issn, ean13) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isngt(issn, ean13) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnne(issn, ean13) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; + +--------------------------------------------------- +-- UPC: +CREATE FUNCTION isnlt(upc, upc) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnle(upc, upc) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isneq(upc, upc) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnge(upc, upc) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isngt(upc, upc) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnne(upc, upc) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; + +CREATE FUNCTION isnlt(upc, ean13) + RETURNS boolean + AS 'int8lt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnle(upc, ean13) + RETURNS boolean + AS 'int8le' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isneq(upc, ean13) + RETURNS boolean + AS 'int8eq' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnge(upc, ean13) + RETURNS boolean + AS 'int8ge' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isngt(upc, ean13) + RETURNS boolean + AS 'int8gt' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION isnne(upc, ean13) + RETURNS boolean + AS 'int8ne' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; + +-- +-- 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 + PARALLEL SAFE; + +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 + PARALLEL SAFE; + +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 + PARALLEL SAFE; +CREATE FUNCTION btean13cmp(ean13, ismn13) + RETURNS int4 + AS 'btint8cmp' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION btean13cmp(ean13, issn13) + RETURNS int4 + AS 'btint8cmp' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION btean13cmp(ean13, isbn) + RETURNS int4 + AS 'btint8cmp' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION btean13cmp(ean13, ismn) + RETURNS int4 + AS 'btint8cmp' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION btean13cmp(ean13, issn) + RETURNS int4 + AS 'btint8cmp' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION btean13cmp(ean13, upc) + RETURNS int4 + AS 'btint8cmp' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; + +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 + PARALLEL SAFE; + +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 + PARALLEL SAFE; + +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 + PARALLEL SAFE; +CREATE FUNCTION btisbn13cmp(isbn13, isbn) + RETURNS int4 + AS 'btint8cmp' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; + +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 + PARALLEL SAFE; + +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 + PARALLEL SAFE; + +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 + PARALLEL SAFE; +CREATE FUNCTION btisbncmp(isbn, isbn13) + RETURNS int4 + AS 'btint8cmp' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; + +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 + PARALLEL SAFE; + +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 + PARALLEL SAFE; + +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 + PARALLEL SAFE; +CREATE FUNCTION btismn13cmp(ismn13, ismn) + RETURNS int4 + AS 'btint8cmp' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; + +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 + PARALLEL SAFE; + +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 + PARALLEL SAFE; + +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 + PARALLEL SAFE; +CREATE FUNCTION btismncmp(ismn, ismn13) + RETURNS int4 + AS 'btint8cmp' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; + +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 + PARALLEL SAFE; + +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 + PARALLEL SAFE; + +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 + PARALLEL SAFE; +CREATE FUNCTION btissn13cmp(issn13, issn) + RETURNS int4 + AS 'btint8cmp' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; + +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 + PARALLEL SAFE; + +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 + PARALLEL SAFE; + +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 + PARALLEL SAFE; +CREATE FUNCTION btissncmp(issn, issn13) + RETURNS int4 + AS 'btint8cmp' + LANGUAGE 'internal' + IMMUTABLE STRICT + PARALLEL SAFE; + +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 + PARALLEL SAFE; + +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 + PARALLEL SAFE; + +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 + PARALLEL SAFE; + +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', 'isbn_cast_from_ean13' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ismn13(ean13) +RETURNS ismn13 +AS 'MODULE_PATHNAME', 'ismn_cast_from_ean13' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION issn13(ean13) +RETURNS issn13 +AS 'MODULE_PATHNAME', 'issn_cast_from_ean13' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION isbn(ean13) +RETURNS isbn +AS 'MODULE_PATHNAME', 'isbn_cast_from_ean13' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ismn(ean13) +RETURNS ismn +AS 'MODULE_PATHNAME', 'ismn_cast_from_ean13' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION issn(ean13) +RETURNS issn +AS 'MODULE_PATHNAME', 'issn_cast_from_ean13' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION upc(ean13) +RETURNS upc +AS 'MODULE_PATHNAME', 'upc_cast_from_ean13' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + + +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) WITHOUT FUNCTION AS ASSIGNMENT; +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 + PARALLEL SAFE; +CREATE FUNCTION make_valid(isbn13) + RETURNS isbn13 + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION make_valid(ismn13) + RETURNS ismn13 + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION make_valid(issn13) + RETURNS issn13 + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION make_valid(isbn) + RETURNS isbn + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION make_valid(ismn) + RETURNS ismn + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION make_valid(issn) + RETURNS issn + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION make_valid(upc) + RETURNS upc + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT + PARALLEL SAFE; + +CREATE FUNCTION is_valid(ean13) + RETURNS boolean + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION is_valid(isbn13) + RETURNS boolean + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION is_valid(ismn13) + RETURNS boolean + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION is_valid(issn13) + RETURNS boolean + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION is_valid(isbn) + RETURNS boolean + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION is_valid(ismn) + RETURNS boolean + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION is_valid(issn) + RETURNS boolean + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT + PARALLEL SAFE; +CREATE FUNCTION is_valid(upc) + RETURNS boolean + AS 'MODULE_PATHNAME' + LANGUAGE C + IMMUTABLE STRICT + PARALLEL SAFE; + +-- +-- 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 + PARALLEL RESTRICTED; + +-- +-- isn_weak() - Gets the weak input mode status +-- +CREATE FUNCTION isn_weak() + RETURNS boolean + AS 'MODULE_PATHNAME', 'weak_input_status' + LANGUAGE C + IMMUTABLE STRICT + PARALLEL RESTRICTED; |