pax_global_header00006660000000000000000000000064151565453630014527gustar00rootroot0000000000000052 comment=95eeabe8458db7cec7e311879c1f6d77dad3d742 db2fce-0.0.17/000077500000000000000000000000001515654536300127415ustar00rootroot00000000000000db2fce-0.0.17/COPYRIGHT.db2fce000066400000000000000000000020351515654536300153600ustar00rootroot00000000000000db2fce, DB2 compatibility environment for PostgreSQL Copyright (c) 2015-2026, credativ GmbH Permission to use, copy, modify, and distribute this software and its documentation for any purpose, without fee, and without a written agreement is hereby granted, provided that the above copyright notice and this paragraph and the following two paragraphs appear in all copies. IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATIONS TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. db2fce-0.0.17/META.json000066400000000000000000000024121515654536300143610ustar00rootroot00000000000000{ "name": "db2fce", "abstract": "DB2 compatibility environment for PostgreSQL", "description": "This module allows usage of well known DB2 functions inside PostgreSQL", "version": "0.0.17", "maintainer": [ "Michael Banck " ], "license": { "PostgreSQL": "http://www.postgresql.org/about/licence" }, "prereqs": { "runtime": { "requires": { "plpgsql": 0, "PostgreSQL": "8.3.0" }, "recommends": { "PostgreSQL": "9.4.0" } } }, "provides": { "db2fce": { "file": "sql/db2fce.sql", "docfile": "README.db2fce", "version": "0.0.17", "abstract": "DB2 compatibility environment for PostgreSQL" } }, "resources": { "homepage": "https://github.com/credativ/db2fce", "repository": { "url": "https://github.com/credativ/db2fce", "web": "https://github.com/credativ/db2fce", "type": "git" } }, "generated_by": "Michael Banck", "meta-spec": { "version": "1.0.0", "url": "http://pgxn.org/meta/spec.txt" }, "release_status": "testing", "tags": [ "db2", "compatibility", "user function", "custom function", ] } db2fce-0.0.17/Makefile000066400000000000000000000014751515654536300144100ustar00rootroot00000000000000EXTENSION = db2fce EXT_VERSION = 0.0.17 DATA = db2fce--${EXT_VERSION}.sql \ db2fce--0.0.4--0.0.5.sql \ db2fce--0.0.5--0.0.6.sql \ db2fce--0.0.6--0.0.7.sql \ db2fce--0.0.7--0.0.8.sql \ db2fce--0.0.8--0.0.9.sql \ db2fce--0.0.9--0.0.10.sql \ db2fce--0.0.10--0.0.11.sql \ db2fce--0.0.11--0.0.12.sql \ db2fce--0.0.12--0.0.13.sql \ db2fce--0.0.13--0.0.14.sql \ db2fce--0.0.14--0.0.15.sql \ db2fce--0.0.15--0.0.16.sql \ db2fce--0.0.16--0.0.17.sql noinst_DATA = db2fce.sql EXTRA_CLEAN = db2fce--${EXT_VERSION}.sql DOCS = COPYRIGHT.db2fce REGRESS = init date_time misc numeric operator string_text PG_CONFIG ?= pg_config PGXS := $(shell $(PG_CONFIG) --pgxs) include $(PGXS) db2fce--${EXT_VERSION}.sql: db2fce.sql sed s/@VERSION@/${EXT_VERSION}/ db2fce.sql > db2fce--${EXT_VERSION}.sql all: db2fce--${EXT_VERSION}.sql db2fce-0.0.17/NEWS000066400000000000000000000037771515654536300134560ustar00rootroot00000000000000db2fce News - History of user-visible changes Copyright (C) 2015-2026 credativ GmbH Version 0.0.17 - 2026-03-18 * Removed remaining NEGATOR (Balázs Bárány) * Dropped oddly named "char" operator, re-created without quotes (Balázs Bárány) * Removed unnecessary implementation of ^= for the internal '"char"' type (Balázs Bárány) * Add update script from v0.0.15 to v0.0.17 to make it possible to jump over v0.0.16. Version 0.0.16 - 2026-01-28 * Removed NEGATOR from ^= operators for PG > 16 compatibility. (Balázs Bárány) . This will lead to worse performance in queries using the ^= operator if the optimizer negates the expression. Version 0.0.15 - 2022-07-12 * Removed array-based concatenation operator aliases Version 0.0.14 - 2021-05-11 * Removed deprecated date types from ^= operator Version 0.0.13 - 2019-08-09 * Build system improvements * Ensure that all objects are created in the db2 schema * Update tests Version 0.0.12 - 2017-06-30 * Added upper() and lower() functions (Balázs Bárány) Version 0.0.11 - 2017-02-20 * Added timestamp_format() function (Balázs Bárány) Version 0.0.10 - 2016-07-25 * Added date() and time() functions (Balázs Bárány) Version 0.0.9 - 2016-06-24 * Modified seconds() and microsseconds() functions to be DB2 compatible (Helmut Hartmann) Version 0.0.8 - 2016-05-09 * Added strip() and digits() functions (Balázs Bárány) Version 0.0.7 - 2016-05-09 * Added update scripts through 0.0.4 Version 0.0.6 - 2016-02-24 * Added lcase() function Version 0.0.5 - 2015-10-27 * Added testsuite Version 0.0.4 - 2015-07-09 * Added !! operator alias for || * Added translate() function * Added hex() function * Added double() function * Added months_between() function * Added microsecond(), second(), minute() and hour() functions Version 0.0.3 - 2015-04-28 * Removed ^= operator alias for pg_lsn and jsonb datatypes for backward compatibility Version 0.0.2 - 2015-04-27 * Corrected schema usage privileges Version 0.0.1 - 2015-04-27 * Initial version db2fce-0.0.17/README.md000066400000000000000000000023421515654536300142210ustar00rootroot00000000000000db2fce, a DB2 compatibility environment for PostgreSQL ====================================================== This extension provides a variety of DB2 functions, types and operators for PostgreSQL. All functions, types and operators are created in the ```db2``` schema. Adding this to the ```search_path``` allows for unmodifed use of (some) DB2 SQL statements. Note that some of the provied functions like ```INT()``` still need to be schema-qualified. SYSIBM.SYSDUMMY1 ---------------- DB2 SELECT statesments require a FROM clause with a table or view, even if no table/view columns are returned (as in PostgreSQL's "SELECT 1;"). In this case, the ```SYSIBM.SYSDUMMY1``` view is customary used by DB2. The SYSIBM schema and this view is provided by db2fce. Installation ------------ Running ```make install``` installs the extension. If ```pg_config``` is not found, you might have to pass its location via the ```PG_CONFIG``` environment variable. Test Suite ---------- An incomplete test suite is available. It can be exercised via ```make installcheck```. The user running the testsuite probably needs elevated privileges in the ```contrib_regress``` database. License ------- db2fce is licensed under the PostgreSQL license. db2fce-0.0.17/db2fce--0.0.10--0.0.11.sql000066400000000000000000000021061515654536300161650ustar00rootroot00000000000000-- TIMESTAMP_FORMAT(): Converts a text to a timestamp using the supplied time format. -- Most format strings are compatible between DB2 and PostgreSQL. CREATE OR REPLACE FUNCTION db2.timestamp_format(text, text) RETURNS TIMESTAMP WITHOUT TIME ZONE AS $FUNC$ select ( -- FFn (n = Number of fractional second digits) with n > 6 is not supported. -- Digits after the 6th are added to the seconds which is not desirable. -- So we change the FF format string to US (microseconds) and truncate the digits to 6. case when $2 ~ '\.FF\d*$' then to_timestamp(regexp_replace($1, '\.(\d{1,6})\d*$', '.\1'), regexp_replace($2, '\.FF\d*$', '.US')) -- Try the original format. Most format strings seem to be identical between PostgreSQL and DB2. else to_timestamp($1, $2) end )::timestamp without time zone; $FUNC$ LANGUAGE SQL IMMUTABLE STRICT COST 50; COMMENT ON FUNCTION db2.timestamp_format(text, text) IS 'Converts a timestamp given as text in the specified format to an actual timestamp'; db2fce-0.0.17/db2fce--0.0.11--0.0.12.sql000066400000000000000000000000001515654536300161560ustar00rootroot00000000000000db2fce-0.0.17/db2fce--0.0.12--0.0.13.sql000066400000000000000000000000001515654536300161600ustar00rootroot00000000000000db2fce-0.0.17/db2fce--0.0.13--0.0.14.sql000066400000000000000000000003601515654536300161730ustar00rootroot00000000000000-- The abstime, reltime and tinterval data types were long deprecated and have -- been removed in PostgreSQL v12 DROP OPERATOR db2.^= (abstime, abstime); DROP OPERATOR db2.^= (reltime, reltime); DROP OPERATOR db2.^= (tinterval, tinterval); db2fce-0.0.17/db2fce--0.0.14--0.0.15.sql000066400000000000000000000004731515654536300162020ustar00rootroot00000000000000-- The array_append(), array_prepend() and array_cat() functions -- that were used for the array-based concetanation operator alias -- had their arguments changed in PostgreSQL v14 DROP OPERATOR db2.!! (anyarray, anyelement); DROP OPERATOR db2.!! (anyelement, anyarray); DROP OPERATOR db2.!! (anyarray, anyarray); db2fce-0.0.17/db2fce--0.0.15--0.0.16.sql000066400000000000000000000354261515654536300162120ustar00rootroot00000000000000-- ^= operator (alias for <> and !=) -- We need to drop the old versions of the operator with the NEGATOR. Duplicate -- negators aren't supported anymore in Postgres. Recreating the operators -- without negator means that the optimizer can't generate NOT() expressions -- for this operator anymore, which can lead to suboptimal performance. DROP OPERATOR IF EXISTS db2.^= (anyarray, anyarray); DROP OPERATOR IF EXISTS db2.^= (anyenum, anyenum); DROP OPERATOR IF EXISTS db2.^= (anyrange, anyrange); DROP OPERATOR IF EXISTS db2.^= (bit, bit); DROP OPERATOR IF EXISTS db2.^= (bool, bool); DROP OPERATOR IF EXISTS db2.^= (bpchar, bpchar); DROP OPERATOR IF EXISTS db2.^= (bytea, bytea); DROP OPERATOR IF EXISTS db2.^= (char, char); DROP OPERATOR IF EXISTS db2.^= (circle, circle); DROP OPERATOR IF EXISTS db2.^= (date, date); DROP OPERATOR IF EXISTS db2.^= (date, timestamp); DROP OPERATOR IF EXISTS db2.^= (date, timestamptz); DROP OPERATOR IF EXISTS db2.^= (float4, float4); DROP OPERATOR IF EXISTS db2.^= (float4, float8); DROP OPERATOR IF EXISTS db2.^= (float8, float4); DROP OPERATOR IF EXISTS db2.^= (float8, float8); DROP OPERATOR IF EXISTS db2.^= (inet, inet); DROP OPERATOR IF EXISTS db2.^= (int2, int2); DROP OPERATOR IF EXISTS db2.^= (int2, int4); DROP OPERATOR IF EXISTS db2.^= (int2, int8); DROP OPERATOR IF EXISTS db2.^= (int4, int2); DROP OPERATOR IF EXISTS db2.^= (int4, int4); DROP OPERATOR IF EXISTS db2.^= (int4, int8); DROP OPERATOR IF EXISTS db2.^= (int8, int2); DROP OPERATOR IF EXISTS db2.^= (int8, int4); DROP OPERATOR IF EXISTS db2.^= (int8, int8); DROP OPERATOR IF EXISTS db2.^= (interval, interval); DROP OPERATOR IF EXISTS db2.^= (lseg, lseg); DROP OPERATOR IF EXISTS db2.^= (macaddr, macaddr); DROP OPERATOR IF EXISTS db2.^= (money, money); DROP OPERATOR IF EXISTS db2.^= (name, name); DROP OPERATOR IF EXISTS db2.^= (numeric, numeric); DROP OPERATOR IF EXISTS db2.^= (oid, oid); DROP OPERATOR IF EXISTS db2.^= (oidvector, oidvector); DROP OPERATOR IF EXISTS db2.^= (point, point); DROP OPERATOR IF EXISTS db2.^= (record, record); DROP OPERATOR IF EXISTS db2.^= (text, text); DROP OPERATOR IF EXISTS db2.^= (tid, tid); DROP OPERATOR IF EXISTS db2.^= (time, time); DROP OPERATOR IF EXISTS db2.^= (timestamp, date); DROP OPERATOR IF EXISTS db2.^= (timestamp, timestamp); DROP OPERATOR IF EXISTS db2.^= (timestamp, timestamptz); DROP OPERATOR IF EXISTS db2.^= (timestamptz, date); DROP OPERATOR IF EXISTS db2.^= (timestamptz, timestamp); DROP OPERATOR IF EXISTS db2.^= (timestamptz, timestamptz); DROP OPERATOR IF EXISTS db2.^= (timetz, timetz); DROP OPERATOR IF EXISTS db2.^= (tsquery, tsquery); DROP OPERATOR IF EXISTS db2.^= (tsvector, tsvector); DROP OPERATOR IF EXISTS db2.^= (uuid, uuid); DROP OPERATOR IF EXISTS db2.^= (varbit, varbit); CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.int48ne, LEFTARG = integer, RIGHTARG = bigint, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (integer, bigint) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.boolne, LEFTARG = boolean, RIGHTARG = boolean, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (boolean, boolean) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.tidne, LEFTARG = tid, RIGHTARG = tid, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (tid, tid) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.int8ne, LEFTARG = bigint, RIGHTARG = bigint, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (bigint, bigint) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.int84ne, LEFTARG = bigint, RIGHTARG = integer, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (bigint, integer) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.int4ne, LEFTARG = integer, RIGHTARG = integer, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (integer, integer) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.int2ne, LEFTARG = smallint, RIGHTARG = smallint, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (smallint, smallint) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.textne, LEFTARG = text, RIGHTARG = text, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (text, text) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.int24ne, LEFTARG = smallint, RIGHTARG = integer, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (smallint, integer) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.int42ne, LEFTARG = integer, RIGHTARG = smallint, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (integer, smallint) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.oidne, LEFTARG = oid, RIGHTARG = oid, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (oid, oid) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.float4ne, LEFTARG = real, RIGHTARG = real, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (real, real) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.namene, LEFTARG = name, RIGHTARG = name, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (name, name) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.oidvectorne, LEFTARG = oidvector, RIGHTARG = oidvector, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (oidvector, oidvector) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.float8ne, LEFTARG = double precision, RIGHTARG = double precision, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (double precision, double precision) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.point_ne, LEFTARG = point, RIGHTARG = point, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (point, point) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.cash_ne, LEFTARG = money, RIGHTARG = money, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (money, money) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.bpcharne, LEFTARG = character, RIGHTARG = character, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (character, character) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.array_ne, LEFTARG = anyarray, RIGHTARG = anyarray, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (anyarray, anyarray) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.date_ne, LEFTARG = date, RIGHTARG = date, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (date, date) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.time_ne, LEFTARG = time without time zone, RIGHTARG = time without time zone, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (time without time zone, time without time zone) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.float48ne, LEFTARG = real, RIGHTARG = double precision, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (real, double precision) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.float84ne, LEFTARG = double precision, RIGHTARG = real, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (double precision, real) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.network_ne, LEFTARG = inet, RIGHTARG = inet, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (inet, inet) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.macaddr_ne, LEFTARG = macaddr, RIGHTARG = macaddr, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (macaddr, macaddr) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.timestamptz_ne, LEFTARG = timestamp with time zone, RIGHTARG = timestamp with time zone, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (timestamp with time zone, timestamp with time zone) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.interval_ne, LEFTARG = interval, RIGHTARG = interval, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (interval, interval) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.circle_ne, LEFTARG = circle, RIGHTARG = circle, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (circle, circle) IS 'not equal by area'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.timetz_ne, LEFTARG = time with time zone, RIGHTARG = time with time zone, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (time with time zone, time with time zone) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.lseg_ne, LEFTARG = lseg, RIGHTARG = lseg, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (lseg, lseg) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.numeric_ne, LEFTARG = numeric, RIGHTARG = numeric, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (numeric, numeric) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.bitne, LEFTARG = bit, RIGHTARG = bit, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (bit, bit) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.varbitne, LEFTARG = bit varying, RIGHTARG = bit varying, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (bit varying, bit varying) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.int28ne, LEFTARG = smallint, RIGHTARG = bigint, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (smallint, bigint) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.int82ne, LEFTARG = bigint, RIGHTARG = smallint, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (bigint, smallint) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.byteane, LEFTARG = bytea, RIGHTARG = bytea, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (bytea, bytea) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.timestamp_ne, LEFTARG = timestamp without time zone, RIGHTARG = timestamp without time zone, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (timestamp without time zone, timestamp without time zone) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.date_ne_timestamp, LEFTARG = date, RIGHTARG = timestamp without time zone, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (date, timestamp without time zone) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.date_ne_timestamptz, LEFTARG = date, RIGHTARG = timestamp with time zone, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (date, timestamp with time zone) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.timestamp_ne_date, LEFTARG = timestamp without time zone, RIGHTARG = date, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (timestamp without time zone, date) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.timestamptz_ne_date, LEFTARG = timestamp with time zone, RIGHTARG = date, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (timestamp with time zone, date) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.timestamp_ne_timestamptz, LEFTARG = timestamp without time zone, RIGHTARG = timestamp with time zone, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (timestamp without time zone, timestamp with time zone) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.timestamptz_ne_timestamp, LEFTARG = timestamp with time zone, RIGHTARG = timestamp without time zone, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (timestamp with time zone, timestamp without time zone) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.uuid_ne, LEFTARG = uuid, RIGHTARG = uuid, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (uuid, uuid) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.record_ne, LEFTARG = record, RIGHTARG = record, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (record, record) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.enum_ne, LEFTARG = anyenum, RIGHTARG = anyenum, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (anyenum, anyenum) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.tsvector_ne, LEFTARG = tsvector, RIGHTARG = tsvector, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (tsvector, tsvector) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.tsquery_ne, LEFTARG = tsquery, RIGHTARG = tsquery, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (tsquery, tsquery) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.range_ne, LEFTARG = anyrange, RIGHTARG = anyrange, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (anyrange, anyrange) IS 'not equal'; db2fce-0.0.17/db2fce--0.0.15--0.0.17.sql000066400000000000000000000427561515654536300162170ustar00rootroot00000000000000-- Upgrade script from 0.0.15 to 0.0.17 -- We need to drop the old versions of the operator with the NEGATOR. Duplicate -- negators aren't supported anymore in Postgres. Recreating the operators -- without negator means that the optimizer can't generate NOT() expressions -- for this operator anymore, which can lead to suboptimal performance. DROP OPERATOR IF EXISTS db2.^= (anyarray, anyarray); DROP OPERATOR IF EXISTS db2.^= (anyenum, anyenum); DROP OPERATOR IF EXISTS db2.^= (anyrange, anyrange); DROP OPERATOR IF EXISTS db2.^= (bit, bit); DROP OPERATOR IF EXISTS db2.^= (bool, bool); DROP OPERATOR IF EXISTS db2.^= (bpchar, bpchar); DROP OPERATOR IF EXISTS db2.^= (bytea, bytea); DROP OPERATOR IF EXISTS db2.^= ("char", "char"); DROP OPERATOR IF EXISTS db2.^= (char, char); DROP OPERATOR IF EXISTS db2.^= (circle, circle); DROP OPERATOR IF EXISTS db2.^= (date, date); DROP OPERATOR IF EXISTS db2.^= (date, timestamp); DROP OPERATOR IF EXISTS db2.^= (date, timestamptz); DROP OPERATOR IF EXISTS db2.^= (float4, float4); DROP OPERATOR IF EXISTS db2.^= (float4, float8); DROP OPERATOR IF EXISTS db2.^= (float8, float4); DROP OPERATOR IF EXISTS db2.^= (float8, float8); DROP OPERATOR IF EXISTS db2.^= (inet, inet); DROP OPERATOR IF EXISTS db2.^= (int2, int2); DROP OPERATOR IF EXISTS db2.^= (int2, int4); DROP OPERATOR IF EXISTS db2.^= (int2, int8); DROP OPERATOR IF EXISTS db2.^= (int4, int2); DROP OPERATOR IF EXISTS db2.^= (int4, int4); DROP OPERATOR IF EXISTS db2.^= (int4, int8); DROP OPERATOR IF EXISTS db2.^= (int8, int2); DROP OPERATOR IF EXISTS db2.^= (int8, int4); DROP OPERATOR IF EXISTS db2.^= (int8, int8); DROP OPERATOR IF EXISTS db2.^= (interval, interval); DROP OPERATOR IF EXISTS db2.^= (lseg, lseg); DROP OPERATOR IF EXISTS db2.^= (macaddr, macaddr); DROP OPERATOR IF EXISTS db2.^= (money, money); DROP OPERATOR IF EXISTS db2.^= (name, name); DROP OPERATOR IF EXISTS db2.^= (numeric, numeric); DROP OPERATOR IF EXISTS db2.^= (oid, oid); DROP OPERATOR IF EXISTS db2.^= (oidvector, oidvector); DROP OPERATOR IF EXISTS db2.^= (point, point); DROP OPERATOR IF EXISTS db2.^= (record, record); DROP OPERATOR IF EXISTS db2.^= (text, text); DROP OPERATOR IF EXISTS db2.^= (tid, tid); DROP OPERATOR IF EXISTS db2.^= (time, time); DROP OPERATOR IF EXISTS db2.^= (timestamp, date); DROP OPERATOR IF EXISTS db2.^= (timestamp, timestamp); DROP OPERATOR IF EXISTS db2.^= (timestamp, timestamptz); DROP OPERATOR IF EXISTS db2.^= (timestamptz, date); DROP OPERATOR IF EXISTS db2.^= (timestamptz, timestamp); DROP OPERATOR IF EXISTS db2.^= (timestamptz, timestamptz); DROP OPERATOR IF EXISTS db2.^= (timetz, timetz); DROP OPERATOR IF EXISTS db2.^= (tsquery, tsquery); DROP OPERATOR IF EXISTS db2.^= (tsvector, tsvector); DROP OPERATOR IF EXISTS db2.^= (uuid, uuid); DROP OPERATOR IF EXISTS db2.^= (varbit, varbit); -- ^= operator (alias for <> and !=) CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.int48ne, LEFTARG = integer, RIGHTARG = bigint, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (integer, bigint) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.boolne, LEFTARG = boolean, RIGHTARG = boolean, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (boolean, boolean) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.tidne, LEFTARG = tid, RIGHTARG = tid, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (tid, tid) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.int8ne, LEFTARG = bigint, RIGHTARG = bigint, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (bigint, bigint) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.int84ne, LEFTARG = bigint, RIGHTARG = integer, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (bigint, integer) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.int4ne, LEFTARG = integer, RIGHTARG = integer, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (integer, integer) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.int2ne, LEFTARG = smallint, RIGHTARG = smallint, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (smallint, smallint) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.textne, LEFTARG = text, RIGHTARG = text, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (text, text) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.int24ne, LEFTARG = smallint, RIGHTARG = integer, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (smallint, integer) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.int42ne, LEFTARG = integer, RIGHTARG = smallint, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (integer, smallint) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.oidne, LEFTARG = oid, RIGHTARG = oid, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (oid, oid) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.float4ne, LEFTARG = real, RIGHTARG = real, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (real, real) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.namene, LEFTARG = name, RIGHTARG = name, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (name, name) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.oidvectorne, LEFTARG = oidvector, RIGHTARG = oidvector, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (oidvector, oidvector) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.float8ne, LEFTARG = double precision, RIGHTARG = double precision, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (double precision, double precision) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.point_ne, LEFTARG = point, RIGHTARG = point, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (point, point) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.cash_ne, LEFTARG = money, RIGHTARG = money, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (money, money) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.bpcharne, LEFTARG = character, RIGHTARG = character, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (character, character) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.array_ne, LEFTARG = anyarray, RIGHTARG = anyarray, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (anyarray, anyarray) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.date_ne, LEFTARG = date, RIGHTARG = date, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (date, date) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.time_ne, LEFTARG = time without time zone, RIGHTARG = time without time zone, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (time without time zone, time without time zone) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.float48ne, LEFTARG = real, RIGHTARG = double precision, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (real, double precision) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.float84ne, LEFTARG = double precision, RIGHTARG = real, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (double precision, real) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.network_ne, LEFTARG = inet, RIGHTARG = inet, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (inet, inet) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.macaddr_ne, LEFTARG = macaddr, RIGHTARG = macaddr, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (macaddr, macaddr) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.timestamptz_ne, LEFTARG = timestamp with time zone, RIGHTARG = timestamp with time zone, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (timestamp with time zone, timestamp with time zone) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.interval_ne, LEFTARG = interval, RIGHTARG = interval, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (interval, interval) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.circle_ne, LEFTARG = circle, RIGHTARG = circle, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (circle, circle) IS 'not equal by area'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.timetz_ne, LEFTARG = time with time zone, RIGHTARG = time with time zone, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (time with time zone, time with time zone) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.lseg_ne, LEFTARG = lseg, RIGHTARG = lseg, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (lseg, lseg) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.numeric_ne, LEFTARG = numeric, RIGHTARG = numeric, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (numeric, numeric) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.bitne, LEFTARG = bit, RIGHTARG = bit, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (bit, bit) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.varbitne, LEFTARG = bit varying, RIGHTARG = bit varying, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (bit varying, bit varying) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.int28ne, LEFTARG = smallint, RIGHTARG = bigint, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (smallint, bigint) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.int82ne, LEFTARG = bigint, RIGHTARG = smallint, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (bigint, smallint) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.byteane, LEFTARG = bytea, RIGHTARG = bytea, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (bytea, bytea) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.timestamp_ne, LEFTARG = timestamp without time zone, RIGHTARG = timestamp without time zone, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (timestamp without time zone, timestamp without time zone) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.date_ne_timestamp, LEFTARG = date, RIGHTARG = timestamp without time zone, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (date, timestamp without time zone) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.date_ne_timestamptz, LEFTARG = date, RIGHTARG = timestamp with time zone, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (date, timestamp with time zone) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.timestamp_ne_date, LEFTARG = timestamp without time zone, RIGHTARG = date, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (timestamp without time zone, date) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.timestamptz_ne_date, LEFTARG = timestamp with time zone, RIGHTARG = date, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (timestamp with time zone, date) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.timestamp_ne_timestamptz, LEFTARG = timestamp without time zone, RIGHTARG = timestamp with time zone, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (timestamp without time zone, timestamp with time zone) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.timestamptz_ne_timestamp, LEFTARG = timestamp with time zone, RIGHTARG = timestamp without time zone, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (timestamp with time zone, timestamp without time zone) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.uuid_ne, LEFTARG = uuid, RIGHTARG = uuid, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (uuid, uuid) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.record_ne, LEFTARG = record, RIGHTARG = record, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (record, record) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.enum_ne, LEFTARG = anyenum, RIGHTARG = anyenum, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (anyenum, anyenum) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.tsvector_ne, LEFTARG = tsvector, RIGHTARG = tsvector, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (tsvector, tsvector) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.tsquery_ne, LEFTARG = tsquery, RIGHTARG = tsquery, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (tsquery, tsquery) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.range_ne, LEFTARG = anyrange, RIGHTARG = anyrange, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (anyrange, anyrange) IS 'not equal'; -- Updates sometimes cause the db2 objects to be in public DROP OPERATOR IF EXISTS public.^= (anyarray, anyarray); DROP OPERATOR IF EXISTS public.^= (anyenum, anyenum); DROP OPERATOR IF EXISTS public.^= (anyrange, anyrange); DROP OPERATOR IF EXISTS public.^= (bit, bit); DROP OPERATOR IF EXISTS public.^= (bool, bool); DROP OPERATOR IF EXISTS public.^= (bpchar, bpchar); DROP OPERATOR IF EXISTS public.^= (bytea, bytea); DROP OPERATOR IF EXISTS public.^= ("char", "char"); DROP OPERATOR IF EXISTS public.^= (char, char); DROP OPERATOR IF EXISTS public.^= (circle, circle); DROP OPERATOR IF EXISTS public.^= (date, date); DROP OPERATOR IF EXISTS public.^= (date, timestamp); DROP OPERATOR IF EXISTS public.^= (date, timestamptz); DROP OPERATOR IF EXISTS public.^= (float4, float4); DROP OPERATOR IF EXISTS public.^= (float4, float8); DROP OPERATOR IF EXISTS public.^= (float8, float4); DROP OPERATOR IF EXISTS public.^= (float8, float8); DROP OPERATOR IF EXISTS public.^= (inet, inet); DROP OPERATOR IF EXISTS public.^= (int2, int2); DROP OPERATOR IF EXISTS public.^= (int2, int4); DROP OPERATOR IF EXISTS public.^= (int2, int8); DROP OPERATOR IF EXISTS public.^= (int4, int2); DROP OPERATOR IF EXISTS public.^= (int4, int4); DROP OPERATOR IF EXISTS public.^= (int4, int8); DROP OPERATOR IF EXISTS public.^= (int8, int2); DROP OPERATOR IF EXISTS public.^= (int8, int4); DROP OPERATOR IF EXISTS public.^= (int8, int8); DROP OPERATOR IF EXISTS public.^= (interval, interval); DROP OPERATOR IF EXISTS public.^= (lseg, lseg); DROP OPERATOR IF EXISTS public.^= (macaddr, macaddr); DROP OPERATOR IF EXISTS public.^= (money, money); DROP OPERATOR IF EXISTS public.^= (name, name); DROP OPERATOR IF EXISTS public.^= (numeric, numeric); DROP OPERATOR IF EXISTS public.^= (oid, oid); DROP OPERATOR IF EXISTS public.^= (oidvector, oidvector); DROP OPERATOR IF EXISTS public.^= (point, point); DROP OPERATOR IF EXISTS public.^= (record, record); DROP OPERATOR IF EXISTS public.^= (text, text); DROP OPERATOR IF EXISTS public.^= (tid, tid); DROP OPERATOR IF EXISTS public.^= (time, time); DROP OPERATOR IF EXISTS public.^= (timestamp, date); DROP OPERATOR IF EXISTS public.^= (timestamp, timestamp); DROP OPERATOR IF EXISTS public.^= (timestamp, timestamptz); DROP OPERATOR IF EXISTS public.^= (timestamptz, date); DROP OPERATOR IF EXISTS public.^= (timestamptz, timestamp); DROP OPERATOR IF EXISTS public.^= (timestamptz, timestamptz); DROP OPERATOR IF EXISTS public.^= (timetz, timetz); DROP OPERATOR IF EXISTS public.^= (tsquery, tsquery); DROP OPERATOR IF EXISTS public.^= (tsvector, tsvector); DROP OPERATOR IF EXISTS public.^= (uuid, uuid); DROP OPERATOR IF EXISTS public.^= (varbit, varbit); db2fce-0.0.17/db2fce--0.0.16--0.0.17.sql000066400000000000000000000053301515654536300162030ustar00rootroot00000000000000-- Upgrade script from 0.0.16 to 0.0.17 DROP OPERATOR IF EXISTS db2.^= ("char", "char"); -- Updates sometimes cause the db2 objects to be in public DROP OPERATOR IF EXISTS public.^= (anyarray, anyarray); DROP OPERATOR IF EXISTS public.^= (anyenum, anyenum); DROP OPERATOR IF EXISTS public.^= (anyrange, anyrange); DROP OPERATOR IF EXISTS public.^= (bit, bit); DROP OPERATOR IF EXISTS public.^= (bool, bool); DROP OPERATOR IF EXISTS public.^= (bpchar, bpchar); DROP OPERATOR IF EXISTS public.^= (bytea, bytea); DROP OPERATOR IF EXISTS public.^= ("char", "char"); DROP OPERATOR IF EXISTS public.^= (char, char); DROP OPERATOR IF EXISTS public.^= (circle, circle); DROP OPERATOR IF EXISTS public.^= (date, date); DROP OPERATOR IF EXISTS public.^= (date, timestamp); DROP OPERATOR IF EXISTS public.^= (date, timestamptz); DROP OPERATOR IF EXISTS public.^= (float4, float4); DROP OPERATOR IF EXISTS public.^= (float4, float8); DROP OPERATOR IF EXISTS public.^= (float8, float4); DROP OPERATOR IF EXISTS public.^= (float8, float8); DROP OPERATOR IF EXISTS public.^= (inet, inet); DROP OPERATOR IF EXISTS public.^= (int2, int2); DROP OPERATOR IF EXISTS public.^= (int2, int4); DROP OPERATOR IF EXISTS public.^= (int2, int8); DROP OPERATOR IF EXISTS public.^= (int4, int2); DROP OPERATOR IF EXISTS public.^= (int4, int4); DROP OPERATOR IF EXISTS public.^= (int4, int8); DROP OPERATOR IF EXISTS public.^= (int8, int2); DROP OPERATOR IF EXISTS public.^= (int8, int4); DROP OPERATOR IF EXISTS public.^= (int8, int8); DROP OPERATOR IF EXISTS public.^= (interval, interval); DROP OPERATOR IF EXISTS public.^= (lseg, lseg); DROP OPERATOR IF EXISTS public.^= (macaddr, macaddr); DROP OPERATOR IF EXISTS public.^= (money, money); DROP OPERATOR IF EXISTS public.^= (name, name); DROP OPERATOR IF EXISTS public.^= (numeric, numeric); DROP OPERATOR IF EXISTS public.^= (oid, oid); DROP OPERATOR IF EXISTS public.^= (oidvector, oidvector); DROP OPERATOR IF EXISTS public.^= (point, point); DROP OPERATOR IF EXISTS public.^= (record, record); DROP OPERATOR IF EXISTS public.^= (text, text); DROP OPERATOR IF EXISTS public.^= (tid, tid); DROP OPERATOR IF EXISTS public.^= (time, time); DROP OPERATOR IF EXISTS public.^= (timestamp, date); DROP OPERATOR IF EXISTS public.^= (timestamp, timestamp); DROP OPERATOR IF EXISTS public.^= (timestamp, timestamptz); DROP OPERATOR IF EXISTS public.^= (timestamptz, date); DROP OPERATOR IF EXISTS public.^= (timestamptz, timestamp); DROP OPERATOR IF EXISTS public.^= (timestamptz, timestamptz); DROP OPERATOR IF EXISTS public.^= (timetz, timetz); DROP OPERATOR IF EXISTS public.^= (tsquery, tsquery); DROP OPERATOR IF EXISTS public.^= (tsvector, tsvector); DROP OPERATOR IF EXISTS public.^= (uuid, uuid); DROP OPERATOR IF EXISTS public.^= (varbit, varbit); db2fce-0.0.17/db2fce--0.0.4--0.0.5.sql000066400000000000000000000000001515654536300160220ustar00rootroot00000000000000db2fce-0.0.17/db2fce--0.0.5--0.0.6.sql000066400000000000000000000002411515654536300160330ustar00rootroot00000000000000CREATE FUNCTION db2.lcase(value text) RETURNS text AS $$ SELECT lower($1); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.lcase(text) IS 'lowercase'; db2fce-0.0.17/db2fce--0.0.6--0.0.7.sql000066400000000000000000000000001515654536300160260ustar00rootroot00000000000000db2fce-0.0.17/db2fce--0.0.7--0.0.8.sql000066400000000000000000000027401515654536300160450ustar00rootroot00000000000000CREATE FUNCTION db2.strip(value text) RETURNS text AS $$ SELECT trim($1); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.strip(text) IS 'Removes blanks from the beginning and end of a string. Alias for trim().'; -- DIGITS() function -- https://www.ibm.com/support/knowledgecenter/SSEPEK_10.0.0/com.ibm.db2z10.doc.sqlref/src/tpc/db2z_bif_digits.dita -- Smallint input: return length = 5 CREATE FUNCTION db2.digits(value smallint) RETURNS varchar(5) AS $func$ SELECT regexp_replace(to_char($1, repeat('0', 5)), '^[ +-]', ''); $func$ LANGUAGE SQL IMMUTABLE STRICT; -- Integer input: return length = 10 CREATE FUNCTION db2.digits(value integer) RETURNS varchar(10) AS $func$ SELECT regexp_replace(to_char($1, repeat('0', 10)), '^[ +-]', ''); $func$ LANGUAGE SQL IMMUTABLE STRICT; -- Bigint input: return length = 19 CREATE FUNCTION db2.digits(value bigint) RETURNS varchar(19) AS $func$ SELECT regexp_replace(to_char($1, repeat('0', 19)), '^[ +-]', ''); $func$ LANGUAGE SQL IMMUTABLE STRICT; -- Generic numeric implementation. -- On numeric(precision,scale) input, the length should depend on the precision of the argument. -- I haven't found a way to determine that. So the formatted number will be returned without leading zeroes. -- The result won't be compatible with DB2 if the value has less digits than its type. CREATE FUNCTION db2.digits(value numeric) RETURNS text as $func$ SELECT regexp_replace($1::text, '[^0-9]', '', 'g'); $func$ LANGUAGE SQL IMMUTABLE STRICT; db2fce-0.0.17/db2fce--0.0.8--0.0.9.sql000066400000000000000000000010661515654536300160470ustar00rootroot00000000000000CREATE OR REPLACE FUNCTION db2.microsecond(value timestamp) RETURNS integer AS $$ SELECT date_part('microsecond', $1)::integer - 1000000 * floor(date_part('second', $1))::integer; $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.microsecond(timestamp) IS 'returns microsecond part of specified timestamp'; CREATE OR REPLACE FUNCTION db2.second(value timestamp) RETURNS integer AS $$ SELECT floor(date_part('second', $1))::integer; $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.second(timestamp) IS 'returns second part of specified timestamp'; db2fce-0.0.17/db2fce--0.0.9--0.0.10.sql000066400000000000000000000026001515654536300161130ustar00rootroot00000000000000CREATE OR REPLACE FUNCTION db2.date(value timestamp) RETURNS date AS $$ SELECT cast(date_trunc('day', $1) as date); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.date(timestamp) IS 'Returns the date part of a timestamp'; CREATE OR REPLACE FUNCTION db2.date(value timestamp with time zone) RETURNS date AS $$ SELECT cast(date_trunc('day', $1) as date); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.date(timestamp with time zone) IS 'Returns the date part of a timestamp'; CREATE OR REPLACE FUNCTION db2.date(value text) RETURNS date AS $$ SELECT cast(date_trunc('day', $1::timestamp) as date); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.date(text) IS 'Returns the date part of a timestamp'; CREATE OR REPLACE FUNCTION db2.time(value timestamp) RETURNS time AS $$ SELECT cast($1 as time); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.time(timestamp) IS 'Returns the time part of a timestamp'; CREATE OR REPLACE FUNCTION db2.time(value timestamp with time zone) RETURNS time AS $$ SELECT cast($1 as time); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.time(timestamp with time zone) IS 'Returns the time part of a timestamp'; CREATE OR REPLACE FUNCTION db2.time(value text) RETURNS time AS $$ SELECT cast($1::timestamp as time); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.time(text) IS 'Returns the time part of a timestamp'; db2fce-0.0.17/db2fce.control000066400000000000000000000002371515654536300154720ustar00rootroot00000000000000# DB2 fce extension comment = 'DB2 compatibility environment for PostgreSQL' default_version = '0.0.17' module_pathname = '$libdir/db2fce' relocatable = false db2fce-0.0.17/db2fce.sql000066400000000000000000001056561515654536300146240ustar00rootroot00000000000000/* contrib/db2fce--@VERSION@.sql */ -- complain if script is sourced in psql, rather than via CREATE EXTENSION \echo Use "CREATE EXTENSION db2fce" to load this file. \quit -- SYSIBM.SYSDUMMY1 emulation CREATE SCHEMA sysibm; GRANT USAGE ON SCHEMA sysibm TO PUBLIC; CREATE VIEW sysibm.sysdummy1 AS SELECT 'X'::char(1) AS ibmreqd; REVOKE ALL ON sysibm.sysdummy1 FROM PUBLIC; GRANT SELECT, REFERENCES ON sysibm.sysdummy1 TO PUBLIC; -- DB2 schema CREATE SCHEMA db2; GRANT USAGE ON SCHEMA db2 TO PUBLIC; SET LOCAL search_path = db2; -- MICROSECOND()/SECOND()/MINUTE()/HOUR() functions CREATE FUNCTION db2.microsecond(value timestamp) RETURNS integer AS $$ SELECT date_part('microsecond', $1)::integer - 1000000 * floor(date_part('second', $1))::integer; $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.microsecond(timestamp) IS 'returns microsecond part of specified timestamp'; CREATE FUNCTION db2.second(value timestamp) RETURNS integer AS $$ SELECT floor(date_part('second', $1))::integer; $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.second(timestamp) IS 'returns second part of specified timestamp'; CREATE FUNCTION db2.minute(value timestamp) RETURNS integer AS $$ SELECT date_part('minute', $1)::integer; $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.minute(timestamp) IS 'returns minute part of specified timestamp'; CREATE FUNCTION db2.hour(value timestamp) RETURNS integer AS $$ SELECT date_part('hour', $1)::integer; $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.hour(timestamp) IS 'returns hour part of specified timestamp'; -- DAY()/MONTH()/YEAR() functions CREATE FUNCTION db2.day(value date) RETURNS integer AS $$ SELECT date_part('day', $1)::integer; $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.day(date) IS 'returns day part of specified date'; CREATE FUNCTION db2.day(value timestamptz) RETURNS integer AS $$ SELECT date_part('day', $1)::integer; $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.day(timestamptz) IS 'returns day part of specified date'; CREATE FUNCTION db2.day(value timestamp) RETURNS integer AS $$ SELECT date_part('day', $1)::integer; $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.day(timestamp) IS 'returns day part of specified date'; CREATE FUNCTION db2.month(value date) RETURNS integer AS $$ SELECT date_part('month', $1)::integer; $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.month(date) IS 'returns month part of specified date'; CREATE FUNCTION db2.month(value timestamptz) RETURNS integer AS $$ SELECT date_part('month', $1)::integer; $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.month(timestamptz) IS 'returns month part of specified date'; CREATE FUNCTION db2.month(value timestamp) RETURNS integer AS $$ SELECT date_part('month', $1)::integer; $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.month(timestamp) IS 'returns month part of specified date'; CREATE FUNCTION db2.year(value date) RETURNS integer AS $$ SELECT date_part('year', $1)::integer; $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.year(date) IS 'returns year part of specified date'; CREATE FUNCTION db2.year(value timestamptz) RETURNS integer AS $$ SELECT date_part('year', $1)::integer; $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.year(timestamptz) IS 'returns year part of specified date'; CREATE FUNCTION db2.year(value timestamp) RETURNS integer AS $$ SELECT date_part('year', $1)::integer; $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.year(timestamp) IS 'returns year part of specified date'; -- DAYS() function CREATE FUNCTION db2.days(value text) RETURNS integer AS $$ SELECT to_date($1, 'YYYY-MM-DD') - to_date('0001-01-01', 'YYYY-MM-DD') + 1; $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.days(text) IS 'returns days since 0000-01-01'; CREATE FUNCTION db2.days(value date) RETURNS integer AS $$ SELECT to_date($1::text, 'YYYY-MM-DD') - to_date('0001-01-01', 'YYYY-MM-DD') + 1; $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.days(date) IS 'returns days since 0000-01-01'; CREATE FUNCTION db2.days(value timestamptz) RETURNS integer AS $$ SELECT to_date($1::text, 'YYYY-MM-DD') - to_date('0001-01-01', 'YYYY-MM-DD') + 1; $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.days(timestamptz) IS 'returns days since 0000-01-01'; CREATE FUNCTION db2.days(value timestamp) RETURNS integer AS $$ SELECT to_date($1::text, 'YYYY-MM-DD') - to_date('0001-01-01', 'YYYY-MM-DD') + 1; $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.days(timestamp) IS 'returns days since 0000-01-01'; -- MONTHS_BETWEEN() function CREATE FUNCTION db2.months_between(date, date) RETURNS numeric AS $$ SELECT (((date_part('year', $1) - date_part('year', $2)) * 12 + date_part('month', $1) - date_part('month', $2) ) + (date_part('day', $1) - date_part('day', $2)) / 31.0 )::DECIMAL(31,15); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.months_between(date, date) IS 'number of months'; -- TODO: MONTHS_BETWEEN('2008-03-31', '2008-02-29') should return 1.00 because -- both dates are last-of-month, see also -- http://www-01.ibm.com/support/knowledgecenter/SSEPEK_11.0.0/com.ibm.db2z11.doc.sqlref/src/tpc/db2z_bif_monthsbetween.dita CREATE FUNCTION db2.months_between(timestamp, timestamp) RETURNS numeric AS $$ SELECT (((date_part('year', $1) - date_part('year', $2)) * 12 + date_part('month', $1) - date_part('month', $2) ) + (((extract(day from $1) * 24 * 60 * 60 + extract(hour from $1) * 60 * 60 + extract(minute from $1) * 60 + extract(second from $1)) - (extract(day from $2) * 24 * 60 * 60 + extract(hour from $2) * 60 * 60 + extract(minute from $2) * 60 + extract(second from $2)) ) / (24 * 60 * 60) ) / 31.0 )::DECIMAL(31,15); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.months_between(timestamp, timestamp) IS 'number of months'; CREATE FUNCTION db2.months_between(date, timestamp) RETURNS numeric AS $$ SELECT (((date_part('year', $1::timestamp) - date_part('year', $2)) * 12 + date_part('month', $1::timestamp) - date_part('month', $2) ) + (((extract(day from $1::timestamp) * 24 * 60 * 60 + extract(hour from $1::timestamp) * 60 * 60 + extract(minute from $1::timestamp) * 60 + extract(second from $1::timestamp)) - (extract(day from $2) * 24 * 60 * 60 + extract(hour from $2) * 60 * 60 + extract(minute from $2) * 60 + extract(second from $2)) ) / (24 * 60 * 60) ) / 31.0 )::DECIMAL(31,15); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.months_between(date, timestamp) IS 'number of months'; CREATE FUNCTION db2.months_between(timestamp, date) RETURNS numeric AS $$ SELECT (((date_part('year', $1) - date_part('year', $2::timestamp)) * 12 + date_part('month', $1) - date_part('month', $2::timestamp) ) + (((extract(day from $1) * 24 * 60 * 60 + extract(hour from $1) * 60 * 60 + extract(minute from $1) * 60 + extract(second from $1)) - (extract(day from $2::timestamp) * 24 * 60 * 60 + extract(hour from $2::timestamp) * 60 * 60 + extract(minute from $2::timestamp) * 60 + extract(second from $2::timestamp)) ) / (24 * 60 * 60) ) / 31.0 )::DECIMAL(31,15); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.months_between(timestamp, date) IS 'number of months'; CREATE FUNCTION db2.months_between(timestamptz, timestamptz) RETURNS numeric AS $$ SELECT (((date_part('year', $1::timestamp) - date_part('year', $2::timestamp)) * 12 + date_part('month', $1::timestamp) - date_part('month', $2::timestamp) ) + (((extract(day from $1::timestamp) * 24 * 60 * 60 + extract(hour from $1::timestamp) * 60 * 60 + extract(minute from $1::timestamp) * 60 + extract(second from $1::timestamp)) - (extract(day from $2::timestamp) * 24 * 60 * 60 + extract(hour from $2::timestamp) * 60 * 60 + extract(minute from $2::timestamp) * 60 + extract(second from $2::timestamp)) ) / (24 * 60 * 60) ) / 31.0 )::DECIMAL(31,15); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.months_between(timestamptz, timestamptz) IS 'number of months'; CREATE FUNCTION db2.months_between(timestamptz, date) RETURNS numeric AS $$ SELECT (((date_part('year', $1::timestamp) - date_part('year', $2::timestamp)) * 12 + date_part('month', $1::timestamp) - date_part('month', $2::timestamp) ) + (((extract(day from $1::timestamp) * 24 * 60 * 60 + extract(hour from $1::timestamp) * 60 * 60 + extract(minute from $1::timestamp) * 60 + extract(second from $1::timestamp)) - (extract(day from $2::timestamp) * 24 * 60 * 60 + extract(hour from $2::timestamp) * 60 * 60 + extract(minute from $2::timestamp) * 60 + extract(second from $2::timestamp)) ) / (24 * 60 * 60) ) / 31.0 )::DECIMAL(31,15); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.months_between(timestamptz, date) IS 'number of months'; CREATE FUNCTION db2.months_between(date, timestamptz) RETURNS numeric AS $$ SELECT (((date_part('year', $1::timestamp) - date_part('year', $2::timestamp)) * 12 + date_part('month', $1::timestamp) - date_part('month', $2::timestamp) ) + (((extract(day from $1::timestamp) * 24 * 60 * 60 + extract(hour from $1::timestamp) * 60 * 60 + extract(minute from $1::timestamp) * 60 + extract(second from $1::timestamp)) - (extract(day from $2::timestamp) * 24 * 60 * 60 + extract(hour from $2::timestamp) * 60 * 60 + extract(minute from $2::timestamp) * 60 + extract(second from $2::timestamp)) ) / (24 * 60 * 60) ) / 31.0 )::DECIMAL(31,15); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.months_between(date, timestamptz) IS 'number of months'; -- DATE()/TIME() functions CREATE OR REPLACE FUNCTION db2.date(value timestamp) RETURNS date AS $$ SELECT cast(date_trunc('day', $1) as date); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.date(timestamp) IS 'Returns the date part of a timestamp'; CREATE OR REPLACE FUNCTION db2.date(value timestamp with time zone) RETURNS date AS $$ SELECT cast(date_trunc('day', $1) as date); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.date(timestamp with time zone) IS 'Returns the date part of a timestamp'; CREATE OR REPLACE FUNCTION db2.date(value text) RETURNS date AS $$ SELECT cast(date_trunc('day', $1::timestamp) as date); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.date(text) IS 'Returns the date part of a timestamp'; CREATE OR REPLACE FUNCTION db2.time(value timestamp) RETURNS time AS $$ SELECT cast($1 as time); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.time(timestamp) IS 'Returns the time part of a timestamp'; CREATE OR REPLACE FUNCTION db2.time(value timestamp with time zone) RETURNS time AS $$ SELECT cast($1 as time); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.time(timestamp with time zone) IS 'Returns the time part of a timestamp'; CREATE OR REPLACE FUNCTION db2.time(value text) RETURNS time AS $$ SELECT cast($1::timestamp as time); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.time(text) IS 'Returns the time part of a timestamp'; -- TIMESTAMP_FORMAT(): Converts a text to a timestamp using the supplied time format. -- Most format strings are compatible between DB2 and PostgreSQL. CREATE OR REPLACE FUNCTION db2.timestamp_format(text, text) RETURNS TIMESTAMP WITHOUT TIME ZONE AS $FUNC$ select ( -- FFn (n = Number of fractional second digits) with n > 6 is not supported. -- Digits after the 6th are added to the seconds which is not desirable. -- So we change the FF format string to US (microseconds) and truncate the digits to 6. case when $2 ~ '\.FF\d*$' then to_timestamp(regexp_replace($1, '\.(\d{1,6})\d*$', '.\1'), regexp_replace($2, '\.FF\d*$', '.US')) -- Try the original format. Most format strings seem to be identical between PostgreSQL and DB2. else to_timestamp($1, $2) end )::timestamp without time zone; $FUNC$ LANGUAGE SQL IMMUTABLE STRICT COST 50; COMMENT ON FUNCTION db2.timestamp_format(text, text) IS 'Converts a timestamp given as text in the specified format to an actual timestamp'; -- LOCATE() function CREATE FUNCTION db2.locate(text, text) RETURNS integer AS $$ SELECT position($1 IN $2); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.locate(text, text) IS 'position of substring'; -- TODO: locate(text, text, int) -- TRANSLATE() function CREATE FUNCTION db2.translate(text, text, text) RETURNS text AS $$ SELECT pg_catalog.translate($1, $3, $2); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.translate(text, text, text) IS 'map a set of characters appearing in string'; -- TODO: translate(text, text, text, pad) CREATE FUNCTION db2.translate(text) RETURNS text AS $$ SELECT upper($1); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.translate(text) IS 'uppercase'; CREATE FUNCTION db2.lcase(value text) RETURNS text AS $$ SELECT lower($1); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.lcase(text) IS 'lowercase'; -- UPPER(text, text): DB2 allows the user to specify a language for the UPPER function. -- This is not really needed with PostgreSQL, as upper() uses Unicode, independent of the language. -- On DB2, upper('Müller', 'en_US') also returns MÜLLER, just as with de_DE. CREATE FUNCTION db2.upper(text, text) RETURNS TEXT AS $$ SELECT upper($1); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.upper(text, text) IS 'uppercase with language as second parameter (ignored)'; -- LOWER(text, text): DB2 allows the user to specify a language for the LOWER function. -- This is not really needed with PostgreSQL, as lower() uses Unicode, independent of the language. CREATE FUNCTION db2.lower(text, text) RETURNS TEXT AS $$ SELECT lower($1); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.lower(text, text) IS 'lowercase with language as second parameter (ignored)'; CREATE FUNCTION db2.strip(value text) RETURNS text AS $$ SELECT trim($1); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.strip(text) IS 'Removes blanks from the beginning and end of a string. Alias for trim().'; -- CHAR()/INTEGER()/INT()/DOUBLE()/DECIMAL()/DEC() functions (CASTs) CREATE FUNCTION db2.char(value text) RETURNS char AS $$ SELECT cast($1 AS CHAR); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.char(text) IS 'cast to char'; CREATE FUNCTION db2.char(value anyelement) RETURNS char AS $$ SELECT cast($1 AS CHAR); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.char(anyelement) IS 'cast to char'; CREATE FUNCTION db2.integer(value text) RETURNS integer AS $$ SELECT cast(floor($1::float) AS INTEGER); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.integer(text) IS 'cast to integer'; CREATE FUNCTION db2.integer(value anyelement) RETURNS integer AS $$ SELECT cast(floor($1::float) AS INTEGER); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.integer(anyelement) IS 'cast to integer'; CREATE FUNCTION db2.int(value text) RETURNS integer AS $$ SELECT cast(floor($1::float) AS INTEGER); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.int(text) IS 'cast to integer'; CREATE FUNCTION db2.int(value anyelement) RETURNS integer AS $$ SELECT cast(floor($1::float) AS INTEGER); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.int(anyelement) IS 'cast to integer'; CREATE FUNCTION db2.double(value text) RETURNS double precision AS $$ SELECT cast($1 AS DOUBLE PRECISION); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.double(text) IS 'cast to double precision'; CREATE FUNCTION db2.double(value anyelement) RETURNS double precision AS $$ SELECT cast($1 AS DOUBLE PRECISION); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.double(anyelement) IS 'cast to double precision'; CREATE FUNCTION db2.decimal(value text) RETURNS decimal AS $$ SELECT cast($1 AS DECIMAL); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.decimal(text) IS 'cast to decimal'; CREATE FUNCTION db2.decimal(value anyelement) RETURNS decimal AS $$ SELECT cast($1 AS DECIMAL); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.decimal(anyelement) IS 'cast to decimal'; CREATE FUNCTION db2.dec(value text) RETURNS decimal AS $$ SELECT cast($1 AS DECIMAL); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.dec(text) IS 'cast to decimal'; CREATE FUNCTION db2.dec(value anyelement) RETURNS decimal AS $$ SELECT cast($1 AS DECIMAL); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.dec(anyelement) IS 'cast to decimal'; -- DECIMAL()/DEC() function with precision and optional scale CREATE FUNCTION db2.decimal(value text, prec integer, scale integer) RETURNS numeric AS $$ DECLARE format text; i int; BEGIN format := ''; FOR i IN 1..$2 LOOP format := format || '9'; END LOOP; format := format || '.'; IF $3 > 0 THEN FOR i IN 1..$3 LOOP format := format || '9'; END LOOP; END IF; RETURN to_number($1::text, format); END $$ LANGUAGE PLPGSQL; COMMENT ON FUNCTION db2.decimal(text, integer, integer) IS 'cast to decimal'; CREATE FUNCTION db2.decimal(value text, prec integer) RETURNS decimal AS $$ SELECT db2."decimal"($1, $2, 0); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.decimal(text, integer) IS 'cast to decimal'; CREATE FUNCTION db2.decimal(value anyelement, prec integer, scale integer) RETURNS decimal AS $$ SELECT db2."decimal"($1::text, $2, $3); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.decimal(anyelement, integer, integer) IS 'cast to decimal'; CREATE FUNCTION db2.decimal(value anyelement, prec integer) RETURNS decimal AS $$ SELECT db2."decimal"($1::text, $2, 0); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.decimal(anyelement, integer) IS 'cast to decimal'; CREATE FUNCTION db2.dec(value text, prec integer, scale integer) RETURNS decimal AS $$ SELECT db2."decimal"($1, $2, $3); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.dec(text, integer, integer) IS 'cast to decimal'; CREATE FUNCTION db2.dec(value text, prec integer) RETURNS decimal AS $$ SELECT db2."decimal"($1, $2, 0); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.dec(text, integer) IS 'cast to decimal'; CREATE FUNCTION db2.dec(value anyelement, prec integer, scale integer) RETURNS decimal AS $$ SELECT cast($1 AS DECIMAL($2, $3)); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.dec(anyelement, integer, integer) IS 'cast to decimal'; CREATE FUNCTION db2.dec(value anyelement, prec integer) RETURNS decimal AS $$ SELECT db2."decimal"($1::text, $2, 0); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.dec(anyelement, integer) IS 'cast to decimal'; -- HEX() function CREATE FUNCTION db2.hex(value text) RETURNS text AS $$ SELECT pg_catalog.encode($1::bytea, 'hex'); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.hex(text) IS 'convert value into hexadecimal string'; -- ROUND() function, additional overloaded signature CREATE FUNCTION db2.round(value double precision, scale integer) RETURNS numeric AS $$ SELECT pg_catalog.round($1::numeric, $2); $$ LANGUAGE SQL IMMUTABLE STRICT; COMMENT ON FUNCTION db2.round(double precision, integer) IS 'value rounded to ''scale'''; -- DIGITS() function -- https://www.ibm.com/support/knowledgecenter/SSEPEK_10.0.0/com.ibm.db2z10.doc.sqlref/src/tpc/db2z_bif_digits.dita -- Smallint input: return length = 5 CREATE FUNCTION db2.digits(value smallint) RETURNS varchar(5) AS $func$ SELECT regexp_replace(to_char($1, repeat('0', 5)), '^[ +-]', ''); $func$ LANGUAGE SQL IMMUTABLE STRICT; -- Integer input: return length = 10 CREATE FUNCTION db2.digits(value integer) RETURNS varchar(10) AS $func$ SELECT regexp_replace(to_char($1, repeat('0', 10)), '^[ +-]', ''); $func$ LANGUAGE SQL IMMUTABLE STRICT; -- Bigint input: return length = 19 CREATE FUNCTION db2.digits(value bigint) RETURNS varchar(19) AS $func$ SELECT regexp_replace(to_char($1, repeat('0', 19)), '^[ +-]', ''); $func$ LANGUAGE SQL IMMUTABLE STRICT; -- Generic numeric implementation. -- On numeric(precision,scale) input, the length should depend on the precision of the argument. -- I haven't found a way to determine that. So the formatted number will be returned without leading zeroes. -- The result won't be compatible with DB2 if the value has less digits than its type. CREATE FUNCTION db2.digits(value numeric) RETURNS text as $func$ SELECT regexp_replace($1::text, '[^0-9]', '', 'g'); $func$ LANGUAGE SQL IMMUTABLE STRICT; -- VALUE() function (alias for COALESCE()) CREATE FUNCTION db2.value(variadic anyarray) RETURNS anyelement AS $$ SELECT $1[i] FROM generate_subscripts($1, 1) g(i) WHERE $1[i] IS NOT NULL LIMIT 1; $$ LANGUAGE SQL STRICT; COMMENT ON FUNCTION db2.value(variadic anyarray) IS 'alias for coalesce'; CREATE FUNCTION db2.value(variadic text[]) RETURNS text AS $$ SELECT $1[i] FROM generate_subscripts($1, 1) g(i) WHERE $1[i] IS NOT NULL LIMIT 1; $$ LANGUAGE SQL STRICT; COMMENT ON FUNCTION db2.value(variadic text[]) IS 'alias for coalesce'; -- DOUBLE type (alias for DOUBLE PRECISION) CREATE DOMAIN db2.double AS double precision; COMMENT ON DOMAIN db2.double IS 'double-precision floating point number, 8-byte storage'; -- ^= operator (alias for <> and !=) CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.int48ne, LEFTARG = integer, RIGHTARG = bigint, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (integer, bigint) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.boolne, LEFTARG = boolean, RIGHTARG = boolean, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (boolean, boolean) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.tidne, LEFTARG = tid, RIGHTARG = tid, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (tid, tid) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.int8ne, LEFTARG = bigint, RIGHTARG = bigint, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (bigint, bigint) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.int84ne, LEFTARG = bigint, RIGHTARG = integer, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (bigint, integer) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.int4ne, LEFTARG = integer, RIGHTARG = integer, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (integer, integer) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.int2ne, LEFTARG = smallint, RIGHTARG = smallint, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (smallint, smallint) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.textne, LEFTARG = text, RIGHTARG = text, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (text, text) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.int24ne, LEFTARG = smallint, RIGHTARG = integer, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (smallint, integer) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.int42ne, LEFTARG = integer, RIGHTARG = smallint, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (integer, smallint) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.oidne, LEFTARG = oid, RIGHTARG = oid, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (oid, oid) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.float4ne, LEFTARG = real, RIGHTARG = real, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (real, real) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.namene, LEFTARG = name, RIGHTARG = name, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (name, name) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.oidvectorne, LEFTARG = oidvector, RIGHTARG = oidvector, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (oidvector, oidvector) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.float8ne, LEFTARG = double precision, RIGHTARG = double precision, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (double precision, double precision) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.point_ne, LEFTARG = point, RIGHTARG = point, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (point, point) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.cash_ne, LEFTARG = money, RIGHTARG = money, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (money, money) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.bpcharne, LEFTARG = character, RIGHTARG = character, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (character, character) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.array_ne, LEFTARG = anyarray, RIGHTARG = anyarray, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (anyarray, anyarray) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.date_ne, LEFTARG = date, RIGHTARG = date, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (date, date) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.time_ne, LEFTARG = time without time zone, RIGHTARG = time without time zone, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (time without time zone, time without time zone) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.float48ne, LEFTARG = real, RIGHTARG = double precision, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (real, double precision) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.float84ne, LEFTARG = double precision, RIGHTARG = real, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (double precision, real) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.network_ne, LEFTARG = inet, RIGHTARG = inet, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (inet, inet) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.macaddr_ne, LEFTARG = macaddr, RIGHTARG = macaddr, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (macaddr, macaddr) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.timestamptz_ne, LEFTARG = timestamp with time zone, RIGHTARG = timestamp with time zone, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (timestamp with time zone, timestamp with time zone) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.interval_ne, LEFTARG = interval, RIGHTARG = interval, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (interval, interval) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.circle_ne, LEFTARG = circle, RIGHTARG = circle, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (circle, circle) IS 'not equal by area'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.timetz_ne, LEFTARG = time with time zone, RIGHTARG = time with time zone, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (time with time zone, time with time zone) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.lseg_ne, LEFTARG = lseg, RIGHTARG = lseg, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (lseg, lseg) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.numeric_ne, LEFTARG = numeric, RIGHTARG = numeric, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (numeric, numeric) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.bitne, LEFTARG = bit, RIGHTARG = bit, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (bit, bit) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.varbitne, LEFTARG = bit varying, RIGHTARG = bit varying, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (bit varying, bit varying) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.int28ne, LEFTARG = smallint, RIGHTARG = bigint, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (smallint, bigint) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.int82ne, LEFTARG = bigint, RIGHTARG = smallint, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (bigint, smallint) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.byteane, LEFTARG = bytea, RIGHTARG = bytea, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (bytea, bytea) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.timestamp_ne, LEFTARG = timestamp without time zone, RIGHTARG = timestamp without time zone, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (timestamp without time zone, timestamp without time zone) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.date_ne_timestamp, LEFTARG = date, RIGHTARG = timestamp without time zone, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (date, timestamp without time zone) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.date_ne_timestamptz, LEFTARG = date, RIGHTARG = timestamp with time zone, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (date, timestamp with time zone) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.timestamp_ne_date, LEFTARG = timestamp without time zone, RIGHTARG = date, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (timestamp without time zone, date) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.timestamptz_ne_date, LEFTARG = timestamp with time zone, RIGHTARG = date, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (timestamp with time zone, date) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.timestamp_ne_timestamptz, LEFTARG = timestamp without time zone, RIGHTARG = timestamp with time zone, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (timestamp without time zone, timestamp with time zone) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.timestamptz_ne_timestamp, LEFTARG = timestamp with time zone, RIGHTARG = timestamp without time zone, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (timestamp with time zone, timestamp without time zone) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.uuid_ne, LEFTARG = uuid, RIGHTARG = uuid, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (uuid, uuid) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.record_ne, LEFTARG = record, RIGHTARG = record, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (record, record) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.enum_ne, LEFTARG = anyenum, RIGHTARG = anyenum, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (anyenum, anyenum) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.tsvector_ne, LEFTARG = tsvector, RIGHTARG = tsvector, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (tsvector, tsvector) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.tsquery_ne, LEFTARG = tsquery, RIGHTARG = tsquery, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (tsquery, tsquery) IS 'not equal'; CREATE OPERATOR db2.^= ( PROCEDURE = pg_catalog.range_ne, LEFTARG = anyrange, RIGHTARG = anyrange, COMMUTATOR = ^=, RESTRICT = neqsel, JOIN = neqjoinsel ); COMMENT ON OPERATOR db2.^= (anyrange, anyrange) IS 'not equal'; -- !! operator (alias for ||) CREATE OPERATOR db2.!! ( PROCEDURE = pg_catalog.textcat, LEFTARG = text, RIGHTARG = text ); COMMENT ON OPERATOR db2.!! (text, text) IS 'concatenate'; CREATE OPERATOR db2.!! ( PROCEDURE = pg_catalog.bitcat, LEFTARG = bit varying, RIGHTARG = bit varying ); COMMENT ON OPERATOR db2.!! (bit varying, bit varying) IS 'concatenate'; CREATE OPERATOR db2.!! ( PROCEDURE = pg_catalog.byteacat, LEFTARG = bytea, RIGHTARG = bytea ); COMMENT ON OPERATOR db2.!! (bytea, bytea) IS 'concatenate'; CREATE OPERATOR db2.!! ( PROCEDURE = pg_catalog.textanycat, LEFTARG = text, RIGHTARG = anynonarray ); COMMENT ON OPERATOR db2.!! (text, anynonarray) IS 'concatenate'; CREATE OPERATOR db2.!! ( PROCEDURE = pg_catalog.anytextcat, LEFTARG = anynonarray, RIGHTARG = text ); COMMENT ON OPERATOR db2.!! (anynonarray, text) IS 'concatenate'; CREATE OPERATOR db2.!! ( PROCEDURE = pg_catalog.tsvector_concat, LEFTARG = tsvector, RIGHTARG = tsvector ); COMMENT ON OPERATOR db2.!! (tsvector, tsvector) IS 'concatenate'; CREATE OPERATOR db2.!! ( PROCEDURE = pg_catalog.tsquery_or, LEFTARG = tsquery, RIGHTARG = tsquery ); COMMENT ON OPERATOR db2.!! (tsquery, tsquery) IS 'OR-concatenate'; RESET search_path; db2fce-0.0.17/expected/000077500000000000000000000000001515654536300145425ustar00rootroot00000000000000db2fce-0.0.17/expected/date_time.out000066400000000000000000000134551515654536300172360ustar00rootroot00000000000000SET search_path = db2,pg_catalog,public; -- MICROSECOND() SELECT MICROSECOND('0001-01-01 00:00:00.100000') FROM SYSIBM.SYSDUMMY1; microsecond ------------- 100000 (1 row) SELECT MICROSECOND('0001-01-01 12:35:30.100001') FROM SYSIBM.SYSDUMMY1; microsecond ------------- 100001 (1 row) SELECT MICROSECOND('0001-01-01 12:35:30.500001') FROM SYSIBM.SYSDUMMY1; microsecond ------------- 500001 (1 row) -- SECOND() SELECT SECOND('0001-01-01 12:35:30.100001') FROM SYSIBM.SYSDUMMY1; second -------- 30 (1 row) SELECT SECOND('0001-01-01 12:35:30.500001') FROM SYSIBM.SYSDUMMY1; second -------- 30 (1 row) -- MINUTE() SELECT MINUTE('0001-01-01 12:35:30.100001') FROM SYSIBM.SYSDUMMY1; minute -------- 35 (1 row) SELECT MINUTE('0001-01-01 12:35:30.100001+02:00') FROM SYSIBM.SYSDUMMY1; minute -------- 35 (1 row) -- HOUR() SELECT HOUR('0001-01-01 12:35:30.100001') FROM SYSIBM.SYSDUMMY1; hour ------ 12 (1 row) SELECT HOUR('0001-01-01 12:35:30.100001+02:00') FROM SYSIBM.SYSDUMMY1; -- WRONG hour ------ 12 (1 row) -- DAY() SELECT DAY('0001-01-01 12:35:30.100001') FROM SYSIBM.SYSDUMMY1; day ----- 1 (1 row) SELECT DAY('1000-01-01') FROM SYSIBM.SYSDUMMY1; day ----- 1 (1 row) SELECT DAY('0004-02-29') FROM SYSIBM.SYSDUMMY1; day ----- 29 (1 row) -- YEAR() SELECT YEAR('0001-01-01') FROM SYSIBM.SYSDUMMY1; year ------ 1 (1 row) -- DAYS() SELECT DAYS('1000-01-01') FROM SYSIBM.SYSDUMMY1; days -------- 364878 (1 row) SELECT DAYS('0000-01-01') FROM SYSIBM.SYSDUMMY1; -- ERROR days ------ -365 (1 row) SELECT DAYS('0001-01-01') FROM SYSIBM.SYSDUMMY1; days ------ 1 (1 row) -- MONTHS_BETWEEN() SELECT MONTHS_BETWEEN('0002-01-01', '0001-01-01') FROM SYSIBM.SYSDUMMY1; months_between -------------------- 12.000000000000000 (1 row) SELECT MONTHS_BETWEEN('0002-01-01', '0001-01-02') FROM SYSIBM.SYSDUMMY1; months_between -------------------- 11.967741935483900 (1 row) SELECT MONTHS_BETWEEN('0002-01-01', '0001-01-03') FROM SYSIBM.SYSDUMMY1; months_between -------------------- 11.935483870967700 (1 row) SELECT MONTHS_BETWEEN('0003-01-01', '0001-01-02') FROM SYSIBM.SYSDUMMY1; months_between -------------------- 23.967741935483900 (1 row) SELECT MONTHS_BETWEEN('2008-01-17', '2008-02-17') FROM SYSIBM.SYSDUMMY1; months_between -------------------- -1.000000000000000 (1 row) SELECT MONTHS_BETWEEN('2008-02-17', '2008-03-17') FROM SYSIBM.SYSDUMMY1; months_between -------------------- -1.000000000000000 (1 row) SELECT MONTHS_BETWEEN('2008-02-20', '2008-01-17') FROM SYSIBM.SYSDUMMY1; months_between ------------------- 1.096774193548390 (1 row) SELECT MONTHS_BETWEEN('2008-01-17', '2008-02-20') FROM SYSIBM.SYSDUMMY1; months_between -------------------- -1.096774193548390 (1 row) SELECT MONTHS_BETWEEN('2008-02-20', '2008-01-20') FROM SYSIBM.SYSDUMMY1; months_between ------------------- 1.000000000000000 (1 row) SELECT MONTHS_BETWEEN('2014-07-09', '2014-06-10') FROM SYSIBM.SYSDUMMY1; months_between ------------------- 0.967741935483871 (1 row) SELECT MONTHS_BETWEEN('2014-07-09 14:00:00.000000', '2014-06-10') FROM SYSIBM.SYSDUMMY1; months_between ------------------- 0.986559139784946 (1 row) SELECT MONTHS_BETWEEN('2014-07-09 14:30:00.000000', '2014-06-10') FROM SYSIBM.SYSDUMMY1; months_between ------------------- 0.987231182795699 (1 row) SELECT MONTHS_BETWEEN('2014-07-09 14:30:30.000000', '2014-06-10') FROM SYSIBM.SYSDUMMY1; months_between ------------------- 0.987242383512545 (1 row) SELECT MONTHS_BETWEEN('2014-07-09 14:30:30.000000+06:00', '2014-06-10') FROM SYSIBM.SYSDUMMY1; months_between ------------------- 0.969769265232975 (1 row) SELECT ROUND(MONTHS_BETWEEN('2008-03-29', '2008-02-29')*31,2) FROM SYSIBM.SYSDUMMY1; round ------- 31.00 (1 row) SELECT ROUND(MONTHS_BETWEEN('2008-03-30', '2008-02-29')*31,2) FROM SYSIBM.SYSDUMMY1; round ------- 32.00 (1 row) SELECT ROUND(MONTHS_BETWEEN('2008-03-31', '2008-02-29')*31,2) FROM SYSIBM.SYSDUMMY1; -- WRONG ("The result round ------- 33.00 (1 row) -- is not 33 because both dates are the last day of their respective month, and so the result is only based -- on the year and month portions.") -- TIMESTAMP_FORMAT() SELECT timestamp_format('2017-04-16 23:59:59.123456789012', 'YYYY-MM-DD HH24:MI:SS.FF12'); timestamp_format --------------------------------- Sun Apr 16 23:59:59.123456 2017 (1 row) SELECT timestamp_format('2017-04-16 23:59:59.123456789', 'YYYY-MM-DD HH24:MI:SS.FF9'); timestamp_format --------------------------------- Sun Apr 16 23:59:59.123456 2017 (1 row) SELECT timestamp_format('2017-04-16 23:59:59.123456', 'YYYY-MM-DD HH24:MI:SS.FF'); timestamp_format --------------------------------- Sun Apr 16 23:59:59.123456 2017 (1 row) SELECT timestamp_format('2017-04-16 23:59:59.1234', 'YYYY-MM-DD HH24:MI:SS.FF'); timestamp_format ------------------------------- Sun Apr 16 23:59:59.1234 2017 (1 row) SELECT timestamp_format('2017-04-16 23:59:59.12', 'YYYY-MM-DD HH24:MI:SS.FF'); timestamp_format ----------------------------- Sun Apr 16 23:59:59.12 2017 (1 row) SELECT timestamp_format('2017-04-16 23:59:59.12', 'YYYY-MM-DD HH24:MI:SS'); timestamp_format -------------------------- Sun Apr 16 23:59:59 2017 (1 row) SELECT timestamp_format('2017-04-16 23:59:59', 'YYYY-MM-DD HH24:MI:SS'); timestamp_format -------------------------- Sun Apr 16 23:59:59 2017 (1 row) SELECT timestamp_format('2017-May-16 23:59:59', 'YYYY-Mon-DD HH24:MI:SS'); timestamp_format -------------------------- Tue May 16 23:59:59 2017 (1 row) SELECT timestamp_format('2017-02-29 13:00:00', 'YYYY-MM-DD HH24:MI:SS'); ERROR: date/time field value out of range: "2017-02-29 13:00:00" CONTEXT: SQL function "timestamp_format" statement 1 db2fce-0.0.17/expected/init.out000066400000000000000000000000311515654536300162300ustar00rootroot00000000000000CREATE EXTENSION db2fce; db2fce-0.0.17/expected/misc.out000066400000000000000000000010341515654536300162240ustar00rootroot00000000000000SET search_path = db2,pg_catalog,public; -- misc tests SELECT INT(5) - (INT(5) / 1000) * 1000 FROM SYSIBM.SYSDUMMY1; ERROR: syntax error at or near "(" LINE 1: SELECT INT(5) - (INT(5) / 1000) * 1000 FROM SYSIBM.SYSDUMMY1... ^ SELECT 5 / 1000 FROM SYSIBM.SYSDUMMY1; ?column? ---------- 0 (1 row) SELECT 5.0 / 1000 FROM SYSIBM.SYSDUMMY1; ?column? ------------------------ 0.00500000000000000000 (1 row) -- SELECT * FROM SYSIBM.SYSDUMMY1 FETCH FIRST 1 ROWS ONLY; ibmreqd --------- X (1 row) db2fce-0.0.17/expected/numeric.out000066400000000000000000000041051515654536300167350ustar00rootroot00000000000000SET search_path = db2,pg_catalog,public; -- INTEGER()/INT() SELECT INTEGER(1.00) FROM SYSIBM.SYSDUMMY1; ERROR: syntax error at or near "(" LINE 1: SELECT INTEGER(1.00) FROM SYSIBM.SYSDUMMY1; ^ SELECT INTEGER(1.50) FROM SYSIBM.SYSDUMMY1; ERROR: syntax error at or near "(" LINE 1: SELECT INTEGER(1.50) FROM SYSIBM.SYSDUMMY1; ^ SELECT INTEGER(1.99) FROM SYSIBM.SYSDUMMY1; ERROR: syntax error at or near "(" LINE 1: SELECT INTEGER(1.99) FROM SYSIBM.SYSDUMMY1; ^ SELECT INTEGER(2.00) FROM SYSIBM.SYSDUMMY1; ERROR: syntax error at or near "(" LINE 1: SELECT INTEGER(2.00) FROM SYSIBM.SYSDUMMY1; ^ SELECT INTEGER(1.99e0) FROM SYSIBM.SYSDUMMY1; ERROR: syntax error at or near "(" LINE 1: SELECT INTEGER(1.99e0) FROM SYSIBM.SYSDUMMY1; ^ SELECT INTEGER(2.00e0) FROM SYSIBM.SYSDUMMY1; ERROR: syntax error at or near "(" LINE 1: SELECT INTEGER(2.00e0) FROM SYSIBM.SYSDUMMY1; ^ SELECT INTEGER(2.00) FROM SYSIBM.SYSDUMMY1; ERROR: syntax error at or near "(" LINE 1: SELECT INTEGER(2.00) FROM SYSIBM.SYSDUMMY1; ^ SELECT INTEGER(1) FROM SYSIBM.SYSDUMMY1; ERROR: syntax error at or near "(" LINE 1: SELECT INTEGER(1) FROM SYSIBM.SYSDUMMY1; ^ SELECT DOUBLE(1.00) FROM SYSIBM.SYSDUMMY1; double -------- 1 (1 row) SELECT CHAR(1.00) FROM SYSIBM.SYSDUMMY1; ERROR: syntax error at or near "1.00" LINE 1: SELECT CHAR(1.00) FROM SYSIBM.SYSDUMMY1; ^ -- ROUND() SELECT ROUND(873.726, 2) FROM SYSIBM.SYSDUMMY1; round -------- 873.73 (1 row) SELECT ROUND(873.726, 1) FROM SYSIBM.SYSDUMMY1; round ------- 873.7 (1 row) SELECT ROUND(873.726, 0) FROM SYSIBM.SYSDUMMY1; round ------- 874 (1 row) SELECT ROUND(873.726, -1) FROM SYSIBM.SYSDUMMY1; round ------- 870 (1 row) SELECT ROUND(873.726, -2) FROM SYSIBM.SYSDUMMY1; round ------- 900 (1 row) SELECT ROUND(873.726, -3) FROM SYSIBM.SYSDUMMY1; round ------- 1000 (1 row) SELECT ROUND(873.726, -4) FROM SYSIBM.SYSDUMMY1; round ------- 0 (1 row) db2fce-0.0.17/expected/operator.out000066400000000000000000000014071515654536300171300ustar00rootroot00000000000000SET search_path = db2,pg_catalog,public; -- VALUE() SELECT VALUE(1) FROM SYSIBM.SYSDUMMY1; -- DB2 ERROR value ------- 1 (1 row) SELECT VALUE(NULL) FROM SYSIBM.SYSDUMMY1; -- DB2 ERROR value ------- (1 row) SELECT VALUE(NULL, NULL) FROM SYSIBM.SYSDUMMY1; -- DB2 ERROR value ------- (1 row) SELECT VALUE(NULL, 1, NULL) FROM SYSIBM.SYSDUMMY1; -- DB2 ERROR value ------- 1 (1 row) SELECT VALUE(NULL, '1', NULL) FROM SYSIBM.SYSDUMMY1; -- DB2 ERROR value ------- 1 (1 row) -- ^= operator SELECT 1 FROM SYSIBM.SYSDUMMY1 WHERE 1 ^= 2; ?column? ---------- 1 (1 row) SELECT 1 FROM SYSIBM.SYSDUMMY1 WHERE 1 ^= 1; ?column? ---------- (0 rows) -- !! operator SELECT 'FOO' !! ' BAR' FROM SYSIBM.SYSDUMMY1; ?column? ---------- FOO BAR (1 row) db2fce-0.0.17/expected/string_text.out000066400000000000000000000024341515654536300176500ustar00rootroot00000000000000SET search_path = db2,pg_catalog,public; -- LOCATE() SELECT LOCATE('N', 'DINING') FROM SYSIBM.SYSDUMMY1; locate -------- 3 (1 row) -- TRANSLATE() SELECT TRANSLATE('12345', 'ax', '143') FROM SYSIBM.SYSDUMMY1; translate ----------- a2x5 (1 row) SELECT TRANSLATE('Hanauma Bay') FROM SYSIBM.SYSDUMMY1; translate ------------- HANAUMA BAY (1 row) SELECT TRANSLATE('Hanauma Bay', 'j', 'B' ) FROM SYSIBM.SYSDUMMY1; translate ------------- Hanauma jay (1 row) SELECT TRANSLATE('Hanauma Bay', 'ei', 'aa') FROM SYSIBM.SYSDUMMY1; translate ------------- Heneume Bey (1 row) SELECT TRANSLATE('Hanauma Bay', 'r', 'Bu') FROM SYSIBM.SYSDUMMY1; translate ------------ Hanama ray (1 row) -- HEX() SELECT HEX('000020') FROM SYSIBM.SYSDUMMY1; hex -------------- 303030303230 (1 row) SELECT HEX(000020) FROM SYSIBM.SYSDUMMY1; -- WRONG ERROR: function hex(integer) does not exist LINE 1: SELECT HEX(000020) FROM SYSIBM.SYSDUMMY1; ^ HINT: No function matches the given name and argument types. You might need to add explicit type casts. -- UPPER(text, text) SELECT UPPER('Müller', 'de_DE') FROM SYSIBM.SYSDUMMY1; upper -------- MÜLLER (1 row) -- LOWER(text, text) SELECT LOWER('MÜLLER', 'de_DE') FROM SYSIBM.SYSDUMMY1; lower -------- müller (1 row) db2fce-0.0.17/parallel_schedule000066400000000000000000000000751515654536300163360ustar00rootroot00000000000000test: init test: date_time misc numeric operator string_text db2fce-0.0.17/sql/000077500000000000000000000000001515654536300135405ustar00rootroot00000000000000db2fce-0.0.17/sql/date_time.sql000066400000000000000000000065161515654536300162240ustar00rootroot00000000000000SET search_path = db2,pg_catalog,public; -- MICROSECOND() SELECT MICROSECOND('0001-01-01 00:00:00.100000') FROM SYSIBM.SYSDUMMY1; SELECT MICROSECOND('0001-01-01 12:35:30.100001') FROM SYSIBM.SYSDUMMY1; SELECT MICROSECOND('0001-01-01 12:35:30.500001') FROM SYSIBM.SYSDUMMY1; -- SECOND() SELECT SECOND('0001-01-01 12:35:30.100001') FROM SYSIBM.SYSDUMMY1; SELECT SECOND('0001-01-01 12:35:30.500001') FROM SYSIBM.SYSDUMMY1; -- MINUTE() SELECT MINUTE('0001-01-01 12:35:30.100001') FROM SYSIBM.SYSDUMMY1; SELECT MINUTE('0001-01-01 12:35:30.100001+02:00') FROM SYSIBM.SYSDUMMY1; -- HOUR() SELECT HOUR('0001-01-01 12:35:30.100001') FROM SYSIBM.SYSDUMMY1; SELECT HOUR('0001-01-01 12:35:30.100001+02:00') FROM SYSIBM.SYSDUMMY1; -- WRONG -- DAY() SELECT DAY('0001-01-01 12:35:30.100001') FROM SYSIBM.SYSDUMMY1; SELECT DAY('1000-01-01') FROM SYSIBM.SYSDUMMY1; SELECT DAY('0004-02-29') FROM SYSIBM.SYSDUMMY1; -- YEAR() SELECT YEAR('0001-01-01') FROM SYSIBM.SYSDUMMY1; -- DAYS() SELECT DAYS('1000-01-01') FROM SYSIBM.SYSDUMMY1; SELECT DAYS('0000-01-01') FROM SYSIBM.SYSDUMMY1; -- ERROR SELECT DAYS('0001-01-01') FROM SYSIBM.SYSDUMMY1; -- MONTHS_BETWEEN() SELECT MONTHS_BETWEEN('0002-01-01', '0001-01-01') FROM SYSIBM.SYSDUMMY1; SELECT MONTHS_BETWEEN('0002-01-01', '0001-01-02') FROM SYSIBM.SYSDUMMY1; SELECT MONTHS_BETWEEN('0002-01-01', '0001-01-03') FROM SYSIBM.SYSDUMMY1; SELECT MONTHS_BETWEEN('0003-01-01', '0001-01-02') FROM SYSIBM.SYSDUMMY1; SELECT MONTHS_BETWEEN('2008-01-17', '2008-02-17') FROM SYSIBM.SYSDUMMY1; SELECT MONTHS_BETWEEN('2008-02-17', '2008-03-17') FROM SYSIBM.SYSDUMMY1; SELECT MONTHS_BETWEEN('2008-02-20', '2008-01-17') FROM SYSIBM.SYSDUMMY1; SELECT MONTHS_BETWEEN('2008-01-17', '2008-02-20') FROM SYSIBM.SYSDUMMY1; SELECT MONTHS_BETWEEN('2008-02-20', '2008-01-20') FROM SYSIBM.SYSDUMMY1; SELECT MONTHS_BETWEEN('2014-07-09', '2014-06-10') FROM SYSIBM.SYSDUMMY1; SELECT MONTHS_BETWEEN('2014-07-09 14:00:00.000000', '2014-06-10') FROM SYSIBM.SYSDUMMY1; SELECT MONTHS_BETWEEN('2014-07-09 14:30:00.000000', '2014-06-10') FROM SYSIBM.SYSDUMMY1; SELECT MONTHS_BETWEEN('2014-07-09 14:30:30.000000', '2014-06-10') FROM SYSIBM.SYSDUMMY1; SELECT MONTHS_BETWEEN('2014-07-09 14:30:30.000000+06:00', '2014-06-10') FROM SYSIBM.SYSDUMMY1; SELECT ROUND(MONTHS_BETWEEN('2008-03-29', '2008-02-29')*31,2) FROM SYSIBM.SYSDUMMY1; SELECT ROUND(MONTHS_BETWEEN('2008-03-30', '2008-02-29')*31,2) FROM SYSIBM.SYSDUMMY1; SELECT ROUND(MONTHS_BETWEEN('2008-03-31', '2008-02-29')*31,2) FROM SYSIBM.SYSDUMMY1; -- WRONG ("The result -- is not 33 because both dates are the last day of their respective month, and so the result is only based -- on the year and month portions.") -- TIMESTAMP_FORMAT() SELECT timestamp_format('2017-04-16 23:59:59.123456789012', 'YYYY-MM-DD HH24:MI:SS.FF12'); SELECT timestamp_format('2017-04-16 23:59:59.123456789', 'YYYY-MM-DD HH24:MI:SS.FF9'); SELECT timestamp_format('2017-04-16 23:59:59.123456', 'YYYY-MM-DD HH24:MI:SS.FF'); SELECT timestamp_format('2017-04-16 23:59:59.1234', 'YYYY-MM-DD HH24:MI:SS.FF'); SELECT timestamp_format('2017-04-16 23:59:59.12', 'YYYY-MM-DD HH24:MI:SS.FF'); SELECT timestamp_format('2017-04-16 23:59:59.12', 'YYYY-MM-DD HH24:MI:SS'); SELECT timestamp_format('2017-04-16 23:59:59', 'YYYY-MM-DD HH24:MI:SS'); SELECT timestamp_format('2017-May-16 23:59:59', 'YYYY-Mon-DD HH24:MI:SS'); SELECT timestamp_format('2017-02-29 13:00:00', 'YYYY-MM-DD HH24:MI:SS'); db2fce-0.0.17/sql/init.sql000066400000000000000000000000311515654536300152160ustar00rootroot00000000000000CREATE EXTENSION db2fce; db2fce-0.0.17/sql/misc.sql000066400000000000000000000004011515654536300152070ustar00rootroot00000000000000SET search_path = db2,pg_catalog,public; -- misc tests SELECT INT(5) - (INT(5) / 1000) * 1000 FROM SYSIBM.SYSDUMMY1; SELECT 5 / 1000 FROM SYSIBM.SYSDUMMY1; SELECT 5.0 / 1000 FROM SYSIBM.SYSDUMMY1; -- SELECT * FROM SYSIBM.SYSDUMMY1 FETCH FIRST 1 ROWS ONLY; db2fce-0.0.17/sql/numeric.sql000066400000000000000000000015221515654536300157230ustar00rootroot00000000000000SET search_path = db2,pg_catalog,public; -- INTEGER()/INT() SELECT INTEGER(1.00) FROM SYSIBM.SYSDUMMY1; SELECT INTEGER(1.50) FROM SYSIBM.SYSDUMMY1; SELECT INTEGER(1.99) FROM SYSIBM.SYSDUMMY1; SELECT INTEGER(2.00) FROM SYSIBM.SYSDUMMY1; SELECT INTEGER(1.99e0) FROM SYSIBM.SYSDUMMY1; SELECT INTEGER(2.00e0) FROM SYSIBM.SYSDUMMY1; SELECT INTEGER(2.00) FROM SYSIBM.SYSDUMMY1; SELECT INTEGER(1) FROM SYSIBM.SYSDUMMY1; SELECT DOUBLE(1.00) FROM SYSIBM.SYSDUMMY1; SELECT CHAR(1.00) FROM SYSIBM.SYSDUMMY1; -- ROUND() SELECT ROUND(873.726, 2) FROM SYSIBM.SYSDUMMY1; SELECT ROUND(873.726, 1) FROM SYSIBM.SYSDUMMY1; SELECT ROUND(873.726, 0) FROM SYSIBM.SYSDUMMY1; SELECT ROUND(873.726, -1) FROM SYSIBM.SYSDUMMY1; SELECT ROUND(873.726, -2) FROM SYSIBM.SYSDUMMY1; SELECT ROUND(873.726, -3) FROM SYSIBM.SYSDUMMY1; SELECT ROUND(873.726, -4) FROM SYSIBM.SYSDUMMY1; db2fce-0.0.17/sql/operator.sql000066400000000000000000000010071515654536300161120ustar00rootroot00000000000000SET search_path = db2,pg_catalog,public; -- VALUE() SELECT VALUE(1) FROM SYSIBM.SYSDUMMY1; -- DB2 ERROR SELECT VALUE(NULL) FROM SYSIBM.SYSDUMMY1; -- DB2 ERROR SELECT VALUE(NULL, NULL) FROM SYSIBM.SYSDUMMY1; -- DB2 ERROR SELECT VALUE(NULL, 1, NULL) FROM SYSIBM.SYSDUMMY1; -- DB2 ERROR SELECT VALUE(NULL, '1', NULL) FROM SYSIBM.SYSDUMMY1; -- DB2 ERROR -- ^= operator SELECT 1 FROM SYSIBM.SYSDUMMY1 WHERE 1 ^= 2; SELECT 1 FROM SYSIBM.SYSDUMMY1 WHERE 1 ^= 1; -- !! operator SELECT 'FOO' !! ' BAR' FROM SYSIBM.SYSDUMMY1; db2fce-0.0.17/sql/string_text.sql000066400000000000000000000012741515654536300166370ustar00rootroot00000000000000SET search_path = db2,pg_catalog,public; -- LOCATE() SELECT LOCATE('N', 'DINING') FROM SYSIBM.SYSDUMMY1; -- TRANSLATE() SELECT TRANSLATE('12345', 'ax', '143') FROM SYSIBM.SYSDUMMY1; SELECT TRANSLATE('Hanauma Bay') FROM SYSIBM.SYSDUMMY1; SELECT TRANSLATE('Hanauma Bay', 'j', 'B' ) FROM SYSIBM.SYSDUMMY1; SELECT TRANSLATE('Hanauma Bay', 'ei', 'aa') FROM SYSIBM.SYSDUMMY1; SELECT TRANSLATE('Hanauma Bay', 'r', 'Bu') FROM SYSIBM.SYSDUMMY1; -- HEX() SELECT HEX('000020') FROM SYSIBM.SYSDUMMY1; SELECT HEX(000020) FROM SYSIBM.SYSDUMMY1; -- WRONG -- UPPER(text, text) SELECT UPPER('Müller', 'de_DE') FROM SYSIBM.SYSDUMMY1; -- LOWER(text, text) SELECT LOWER('MÜLLER', 'de_DE') FROM SYSIBM.SYSDUMMY1; db2fce-0.0.17/test.sql000066400000000000000000000106761515654536300144530ustar00rootroot00000000000000-- MICROSECOND() SELECT MICROSECOND('0001-01-01 00:00:00.100000') FROM SYSIBM.SYSDUMMY1; SELECT MICROSECOND('0001-01-01 12:35:30.100001') FROM SYSIBM.SYSDUMMY1; -- SECOND() SELECT SECOND('0001-01-01 12:35:30.100001') FROM SYSIBM.SYSDUMMY1; -- MINUTE() SELECT MINUTE('0001-01-01 12:35:30.100001') FROM SYSIBM.SYSDUMMY1; SELECT MINUTE('0001-01-01 12:35:30.100001+02:00') FROM SYSIBM.SYSDUMMY1; -- HOUR() SELECT HOUR('0001-01-01 12:35:30.100001') FROM SYSIBM.SYSDUMMY1; SELECT HOUR('0001-01-01 12:35:30.100001+02:00') FROM SYSIBM.SYSDUMMY1; -- WRONG -- DAY() SELECT DAY('0001-01-01 12:35:30.100001') FROM SYSIBM.SYSDUMMY1; SELECT DAY('1000-01-01') FROM SYSIBM.SYSDUMMY1; SELECT DAY('0004-02-29') FROM SYSIBM.SYSDUMMY1; -- YEAR() SELECT YEAR('0001-01-01') FROM SYSIBM.SYSDUMMY1; SELECT YEAR(CURRENT_TIMESTAMP) FROM SYSIBM.SYSDUMMY1; -- DAYS() SELECT DAYS('1000-01-01') FROM SYSIBM.SYSDUMMY1; SELECT DAYS('0000-01-01') FROM SYSIBM.SYSDUMMY1; -- ERROR SELECT DAYS('0001-01-01') FROM SYSIBM.SYSDUMMY1; -- MONTHS_BETWEEN() SELECT MONTHS_BETWEEN('0002-01-01', '0001-01-01') FROM SYSIBM.SYSDUMMY1; SELECT MONTHS_BETWEEN('0002-01-01', '0001-01-02') FROM SYSIBM.SYSDUMMY1; SELECT MONTHS_BETWEEN('0002-01-01', '0001-01-03') FROM SYSIBM.SYSDUMMY1; SELECT MONTHS_BETWEEN('0003-01-01', '0001-01-02') FROM SYSIBM.SYSDUMMY1; SELECT MONTHS_BETWEEN('2008-01-17', '2008-02-17') FROM SYSIBM.SYSDUMMY1; SELECT MONTHS_BETWEEN('2008-02-17', '2008-03-17') FROM SYSIBM.SYSDUMMY1; SELECT MONTHS_BETWEEN('2008-02-20', '2008-01-17') FROM SYSIBM.SYSDUMMY1; SELECT MONTHS_BETWEEN('2008-01-17', '2008-02-20') FROM SYSIBM.SYSDUMMY1; SELECT MONTHS_BETWEEN('2008-02-20', '2008-01-20') FROM SYSIBM.SYSDUMMY1; SELECT MONTHS_BETWEEN('2014-07-09', '2014-06-10') FROM SYSIBM.SYSDUMMY1; SELECT MONTHS_BETWEEN('2014-07-09 14:00:00.000000', '2014-06-10') FROM SYSIBM.SYSDUMMY1; SELECT MONTHS_BETWEEN('2014-07-09 14:30:00.000000', '2014-06-10') FROM SYSIBM.SYSDUMMY1; SELECT MONTHS_BETWEEN('2014-07-09 14:30:30.000000', '2014-06-10') FROM SYSIBM.SYSDUMMY1; SELECT MONTHS_BETWEEN('2014-07-09 14:30:30.000000+06:00', '2014-06-10') FROM SYSIBM.SYSDUMMY1; SELECT ROUND(MONTHS_BETWEEN('2008-03-29', '2008-02-29')*31,2) FROM SYSIBM.SYSDUMMY1; SELECT ROUND(MONTHS_BETWEEN('2008-03-30', '2008-02-29')*31,2) FROM SYSIBM.SYSDUMMY1; SELECT ROUND(MONTHS_BETWEEN('2008-03-31', '2008-02-29')*31,2) FROM SYSIBM.SYSDUMMY1; -- WRONG ("The result -- is not 33 because both dates are the last day of their respective month, and so the result is only based -- on the year and month portions.") -- LOCATE() SELECT LOCATE('N', 'DINING') FROM SYSIBM.SYSDUMMY1; -- TRANSLATE() SELECT TRANSLATE('12345', 'ax', '143') FROM SYSIBM.SYSDUMMY1; SELECT TRANSLATE('Hanauma Bay') FROM SYSIBM.SYSDUMMY1; SELECT TRANSLATE('Hanauma Bay', 'j', 'B' ) FROM SYSIBM.SYSDUMMY1; SELECT TRANSLATE('Hanauma Bay', 'ei', 'aa') FROM SYSIBM.SYSDUMMY1; SELECT TRANSLATE('Hanauma Bay', 'r', 'Bu') FROM SYSIBM.SYSDUMMY1; -- INTEGER()/INT() SELECT INTEGER(1.00) FROM SYSIBM.SYSDUMMY1; SELECT INTEGER(1.50) FROM SYSIBM.SYSDUMMY1; SELECT INTEGER(1.99) FROM SYSIBM.SYSDUMMY1; SELECT INTEGER(2.00) FROM SYSIBM.SYSDUMMY1; SELECT INTEGER(1.99e0) FROM SYSIBM.SYSDUMMY1; SELECT INTEGER(2.00e0) FROM SYSIBM.SYSDUMMY1; SELECT INTEGER(2.00) FROM SYSIBM.SYSDUMMY1; SELECT INTEGER(1) FROM SYSIBM.SYSDUMMY1; SELECT DOUBLE(1.00) FROM SYSIBM.SYSDUMMY1; SELECT CHAR(1.00) FROM SYSIBM.SYSDUMMY1; -- HEX() SELECT HEX('000020') FROM SYSIBM.SYSDUMMY1; SELECT HEX(000020) FROM SYSIBM.SYSDUMMY1; -- WRONG -- ROUND() SELECT ROUND(873.726, 2) FROM SYSIBM.SYSDUMMY1; SELECT ROUND(873.726, 1) FROM SYSIBM.SYSDUMMY1; SELECT ROUND(873.726, 0) FROM SYSIBM.SYSDUMMY1; SELECT ROUND(873.726, -1) FROM SYSIBM.SYSDUMMY1; SELECT ROUND(873.726, -2) FROM SYSIBM.SYSDUMMY1; SELECT ROUND(873.726, -3) FROM SYSIBM.SYSDUMMY1; SELECT ROUND(873.726, -4) FROM SYSIBM.SYSDUMMY1; -- VALUE() SELECT VALUE(1) FROM SYSIBM.SYSDUMMY1; -- DB2 ERROR SELECT VALUE(NULL) FROM SYSIBM.SYSDUMMY1; -- DB2 ERROR SELECT VALUE(NULL, NULL) FROM SYSIBM.SYSDUMMY1; -- DB2 ERROR SELECT VALUE(NULL, 1, NULL) FROM SYSIBM.SYSDUMMY1; -- DB2 ERROR SELECT VALUE(NULL, '1', NULL) FROM SYSIBM.SYSDUMMY1; -- DB2 ERROR -- ^= operator SELECT 1 FROM SYSIBM.SYSDUMMY1 WHERE 1 ^= 2; SELECT 1 FROM SYSIBM.SYSDUMMY1 WHERE 1 ^= 1; -- !! operator SELECT 'FOO' !! ' BAR' FROM SYSIBM.SYSDUMMY1; -- misc tests SELECT INT(5) - (INT(5) / 1000) * 1000 FROM SYSIBM.SYSDUMMY1; SELECT 5 / 1000 FROM SYSIBM.SYSDUMMY1; SELECT 5.0 / 1000 FROM SYSIBM.SYSDUMMY1; -- SELECT * FROM SYSIBM.SYSDUMMY1 FETCH FIRST 1 ROWS ONLY;