├── .gitattributes ├── .travis.yml ├── META.json ├── Makefile ├── README ├── doc └── tinyint.md ├── expected └── tinyint.out ├── sql └── tinyint.sql ├── tinyint.c ├── tinyint.control ├── tinyint.h ├── tinyint.sql.in.c └── uninstall_tinyint.sql /.gitattributes: -------------------------------------------------------------------------------- 1 | * text=auto 2 | *.c text 3 | *.h text 4 | *.sql text 5 | *.control text 6 | *.json text 7 | Makefile text 8 | -------------------------------------------------------------------------------- /.travis.yml: -------------------------------------------------------------------------------- 1 | sudo: required 2 | dist: trusty 3 | language: c 4 | matrix: 5 | include: 6 | - addons: 7 | postgresql: 9.3 8 | env: 9 | - POSTGRESQL=9.3 10 | install: 11 | - sudo apt-get install postgresql-server-dev-9.3 12 | - sudo make install 13 | - addons: 14 | postgresql: 9.4 15 | env: 16 | - POSTGRESQL=9.4 17 | install: 18 | - sudo apt-get install postgresql-server-dev-9.4 19 | - sudo make install 20 | - addons: 21 | postgresql: 9.5 22 | install: 23 | - sudo apt-get install postgresql-server-dev-9.5 24 | - sudo make install 25 | env: 26 | - POSTGRESQL=9.5 27 | - addons: 28 | postgresql: 9.6 29 | install: 30 | - sudo apt-get install postgresql-server-dev-9.6 31 | - sudo make install 32 | env: 33 | - POSTGRESQL=9.6 34 | - # addons: postgresql: 10 35 | install: 36 | - sudo service postgresql stop 37 | - wget -q https://www.postgresql.org/media/keys/ACCC4CF8.asc -O - | sudo apt-key add - 38 | - sudo sh -c 'echo "deb http://apt.postgresql.org/pub/repos/apt/ `lsb_release -cs`-pgdg main" >> /etc/apt/sources.list.d/pgdg.list' 39 | - sudo apt-get update 40 | - sudo apt-get install postgresql postgresql-contrib postgresql-client 41 | - sudo apt-get install postgresql-server-dev-10 42 | - sudo sh -c 'echo "port=5432" >> /etc/postgresql/10/main/postgresql.conf' 43 | - sudo pg_ctlcluster 10 main restart 44 | - sudo -u postgres psql -c "create user travis with superuser"; 45 | - sudo make install 46 | env: 47 | - POSTGRESQL=10 48 | script: 49 | - make installcheck 50 | after_failure: 51 | - cat regression.diffs 52 | -------------------------------------------------------------------------------- /META.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "tinyint", 3 | "abstract": "1 byte integer data type", 4 | "description": "This provides 1 byte integer with full set of operators, index access methods and definition of them.", 5 | "version": "0.1.1", 6 | "maintainer": "Hitoshi Harada ", 7 | "license": "postgresql", 8 | "provides": { 9 | "tinyint": { 10 | "abstract": "1 byte integer", 11 | "version": "0.1.1", 12 | "file": "tinyint.sql", 13 | "docfile": "doc/tinyint.md" 14 | } 15 | }, 16 | "resources": { 17 | "bugtracker": { 18 | "web": "http://github.com/umitanuki/tinyint-postgresql/issues/" 19 | }, 20 | "repository": { 21 | "url": "git://github.com/umitanuki/tinyint-postgresql.git", 22 | "web": "http://github.com/umitanuki/tinyint-postgresql", 23 | "type": "git" 24 | } 25 | }, 26 | "meta-spec": { 27 | "version": "1.0.0", 28 | "url": "http://pgxn.org/meta/spec.txt" 29 | }, 30 | "tags": [ 31 | "datatype", 32 | "integer", 33 | "tinyint" 34 | ] 35 | } 36 | -------------------------------------------------------------------------------- /Makefile: -------------------------------------------------------------------------------- 1 | PG_CONFIG ?= pg_config 2 | 3 | EXTENSION = tinyint 4 | EXTVERSION = 0.1.1 5 | EXTSQL = $(EXTENSION)--$(EXTVERSION).sql 6 | 7 | MODULES = tinyint 8 | OBJS = tinyint.o 9 | DATA_built = tinyint.sql 10 | DATA = uninstall_tinyint.sql 11 | DOCS = doc/tinyint.md 12 | REGRESS = tinyint 13 | 14 | SQL_IN = tinyint.sql.in 15 | EXTRA_CLEAN += $(SQL_IN) $(EXTSQL) 16 | 17 | USE_EXTENSION = $(shell $(pg_config) --version | grep -qE " 8\.|9\.0" && echo no || echo yes) 18 | 19 | ifeq ($(USE_EXTENSION),yes) 20 | all: $(EXTSQL) 21 | 22 | $(EXTSQL): $(EXTENSION).sql 23 | cp $< $@ 24 | 25 | DATA = $(EXTSQL) 26 | endif 27 | 28 | PGXS := $(shell $(pg_config) --pgxs) 29 | include $(PGXS) 30 | 31 | $(SQL_IN): tinyint.sql.in.c 32 | $(CC) -E -P $(CPPFLAGS) $< > $@ 33 | -------------------------------------------------------------------------------- /README: -------------------------------------------------------------------------------- 1 | tinyint-postgresql 2 | 3 | This is an extension that impelements tinyint (1 byte integer) as a data type 4 | of PostgreSQL. Traditionally, PostgreSQL core has a policy not to have 1 byte 5 | integer in it. With this module, you can define 1 byte integer column on your 6 | tables, which will help query performances and portabilities from other RDBMS. 7 | 8 | 9 | Hitoshi Harada 10 | -------------------------------------------------------------------------------- /doc/tinyint.md: -------------------------------------------------------------------------------- 1 | tinyint 0.1.1 2 | ============= 3 | 4 | Synopsis 5 | -------- 6 | 7 | % CREATE EXTENSION tinyint; 8 | CREATE EXTENSION 9 | 10 | % SELECT 1::tinyint; 11 | 12 | 13 | Description 14 | ----------- 15 | 16 | This module provides 1 byte signed integer type with operators, 17 | index access methods and support functions. You can use it as 18 | like the corresponding data type in other RDBMS as well as 19 | smallint, integer or bigint in PostgreSQL. Although the byte 20 | used for 1 tinyint is exactly 1 byte, you need to take account 21 | into its position in the row if you really care the table size 22 | since PostgreSQL usually pads extra bytes for the alignment of 4. 23 | 24 | tinyint holds -127 to 127. +, -, *, %. min(), max(), sum(), avg(), 25 | btree index and gin index are supported as other integer types. 26 | 27 | Support 28 | ------- 29 | 30 | This library is stored in an open [GitHub 31 | repository](http://github.com/umitanuki/tinyint-postgresql). 32 | Feel free to fork and contribute! Please file bug reports 33 | via [GitHub Issues](http://github.com/umitanuki/tinyint-postgresql/issues/). 34 | 35 | Author 36 | ------ 37 | 38 | [Hitoshi Harada](mailto:umi.tanuki@gmail.com) 39 | 40 | Copyright and License 41 | --------------------- 42 | 43 | Copyright (c) Hitoshi Harada 44 | 45 | This module is free software; you can redistribute it and/or modify it under 46 | the [PostgreSQL License](http://www.opensource.org/licenses/postgresql). 47 | 48 | Permission to use, copy, modify, and distribute this software and its 49 | documentation for any purpose, without fee, and without a written agreement is 50 | hereby granted, provided that the above copyright notice and this paragraph 51 | and the following two paragraphs appear in all copies. 52 | 53 | In no event shall Hitoshi Harada be liable to any party for direct, 54 | indirect, special, incidental, or consequential damages, including 55 | lost profits, arising out of the use of this software and its documentation, 56 | even if Hitoshi Harada has been advised of the possibility of such damage. 57 | 58 | Hitoshi Harada specifically disclaim any warranties, 59 | including, but not limited to, the implied warranties of merchantability and 60 | fitness for a particular purpose. The software provided hereunder is on an "as 61 | is" basis, and Hitoshi Harada has no obligations to provide maintenance, 62 | support, updates, enhancements, or modifications. 63 | 64 | -------------------------------------------------------------------------------- /expected/tinyint.out: -------------------------------------------------------------------------------- 1 | SET client_min_messages = warning; 2 | \set ECHO none 3 | RESET client_min_messages; 4 | SELECT 0::tinyint; 5 | tinyint 6 | --------- 7 | 0 8 | (1 row) 9 | 10 | SELECT 1::integer::tinyint::smallint::tinyint::bigint::tinyint; 11 | tinyint 12 | --------- 13 | 1 14 | (1 row) 15 | 16 | SELECT 1::tinyint < 2::tinyint; 17 | ?column? 18 | ---------- 19 | t 20 | (1 row) 21 | 22 | SELECT -1::tinyint > +10::tinyint; 23 | ?column? 24 | ---------- 25 | f 26 | (1 row) 27 | 28 | SELECT 1::smallint > 0::tinyint; 29 | ?column? 30 | ---------- 31 | t 32 | (1 row) 33 | 34 | SELECT 1::integer > 0::tinyint; 35 | ?column? 36 | ---------- 37 | t 38 | (1 row) 39 | 40 | SELECT 1::bigint > 0::tinyint; 41 | ?column? 42 | ---------- 43 | t 44 | (1 row) 45 | 46 | SELECT 1::tinyint < 0::smallint; 47 | ?column? 48 | ---------- 49 | f 50 | (1 row) 51 | 52 | SELECT 1::tinyint < 0::integer; 53 | ?column? 54 | ---------- 55 | f 56 | (1 row) 57 | 58 | SELECT 1::tinyint < 0::bigint; 59 | ?column? 60 | ---------- 61 | f 62 | (1 row) 63 | 64 | SELECT 1::tinyint + 1::tinyint; 65 | ?column? 66 | ---------- 67 | 2 68 | (1 row) 69 | 70 | SELECT 1::tinyint + 1::smallint; 71 | ?column? 72 | ---------- 73 | 2 74 | (1 row) 75 | 76 | SELECT 1::tinyint + 1::integer; 77 | ?column? 78 | ---------- 79 | 2 80 | (1 row) 81 | 82 | SELECT 1::tinyint + 1::bigint; 83 | ?column? 84 | ---------- 85 | 2 86 | (1 row) 87 | 88 | SELECT 1::smallint + 1::tinyint; 89 | ?column? 90 | ---------- 91 | 2 92 | (1 row) 93 | 94 | SELECT 1::integer + 1::tinyint; 95 | ?column? 96 | ---------- 97 | 2 98 | (1 row) 99 | 100 | SELECT 1::bigint + 1::tinyint; 101 | ?column? 102 | ---------- 103 | 2 104 | (1 row) 105 | 106 | SELECT 2::tinyint * 2::tinyint; 107 | ?column? 108 | ---------- 109 | 4 110 | (1 row) 111 | 112 | SELECT 4::tinyint / -2::tinyint; 113 | ?column? 114 | ---------- 115 | -2 116 | (1 row) 117 | 118 | SELECT 2::smallint * 2::tinyint; 119 | ?column? 120 | ---------- 121 | 4 122 | (1 row) 123 | 124 | SELECT 2::integer * 2::tinyint; 125 | ?column? 126 | ---------- 127 | 4 128 | (1 row) 129 | 130 | SELECT 2::bigint * 2::tinyint; 131 | ?column? 132 | ---------- 133 | 4 134 | (1 row) 135 | 136 | SELECT 2::smallint / 2::tinyint; 137 | ?column? 138 | ---------- 139 | 1 140 | (1 row) 141 | 142 | SELECT 2::integer / 2::tinyint; 143 | ?column? 144 | ---------- 145 | 1 146 | (1 row) 147 | 148 | SELECT 2::bigint / 2::tinyint; 149 | ?column? 150 | ---------- 151 | 1 152 | (1 row) 153 | 154 | SELECT 2::tinyint * 2::smallint; 155 | ?column? 156 | ---------- 157 | 4 158 | (1 row) 159 | 160 | SELECT 2::tinyint * 2::integer; 161 | ?column? 162 | ---------- 163 | 4 164 | (1 row) 165 | 166 | SELECT 2::tinyint * 2::bigint; 167 | ?column? 168 | ---------- 169 | 4 170 | (1 row) 171 | 172 | SELECT 2::tinyint / 2::smallint; 173 | ?column? 174 | ---------- 175 | 1 176 | (1 row) 177 | 178 | SELECT 2::tinyint / 2::integer; 179 | ?column? 180 | ---------- 181 | 1 182 | (1 row) 183 | 184 | SELECT 2::tinyint / 2::bigint; 185 | ?column? 186 | ---------- 187 | 1 188 | (1 row) 189 | 190 | SELECT MAX(val), MIN(val), AVG(val), SUM(val) FROM (VALUES('1'::tinyint),('2'),('5'),('10')) AS s(val); 191 | max | min | avg | sum 192 | -----+-----+--------------------+----- 193 | 10 | 1 | 4.5000000000000000 | 18 194 | (1 row) 195 | 196 | CREATE TABLE t_tinyint (vals tinyint[]); 197 | INSERT INTO t_tinyint VALUES('{0,0,0,1,2,3,0}'),('{1,2,100,127,-126}'::tinyint[]); 198 | CREATE INDEX t_tinyint_gin ON t_tinyint USING gin(vals); 199 | SELECT 128::tinyint; 200 | ERROR: tinyint out of range 201 | SELECT 16::tinyint * 16::tinyint; 202 | ERROR: tinyint out of range 203 | SELECT 127::tinyint * 32767::smallint; 204 | ERROR: smallint out of range 205 | SELECT 16::tinyint / 0; 206 | ERROR: division by zero 207 | SELECT (1::bigint << 63) * 2::tinyint; 208 | ERROR: bigint out of range 209 | -------------------------------------------------------------------------------- /sql/tinyint.sql: -------------------------------------------------------------------------------- 1 | SET client_min_messages = warning; 2 | \set ECHO none 3 | \i tinyint.sql 4 | \set ECHO all 5 | RESET client_min_messages; 6 | 7 | SELECT 0::tinyint; 8 | SELECT 1::integer::tinyint::smallint::tinyint::bigint::tinyint; 9 | 10 | SELECT 1::tinyint < 2::tinyint; 11 | SELECT -1::tinyint > +10::tinyint; 12 | SELECT 1::smallint > 0::tinyint; 13 | SELECT 1::integer > 0::tinyint; 14 | SELECT 1::bigint > 0::tinyint; 15 | SELECT 1::tinyint < 0::smallint; 16 | SELECT 1::tinyint < 0::integer; 17 | SELECT 1::tinyint < 0::bigint; 18 | 19 | SELECT 1::tinyint + 1::tinyint; 20 | SELECT 1::tinyint + 1::smallint; 21 | SELECT 1::tinyint + 1::integer; 22 | SELECT 1::tinyint + 1::bigint; 23 | SELECT 1::smallint + 1::tinyint; 24 | SELECT 1::integer + 1::tinyint; 25 | SELECT 1::bigint + 1::tinyint; 26 | SELECT 2::tinyint * 2::tinyint; 27 | SELECT 4::tinyint / -2::tinyint; 28 | SELECT 2::smallint * 2::tinyint; 29 | SELECT 2::integer * 2::tinyint; 30 | SELECT 2::bigint * 2::tinyint; 31 | SELECT 2::smallint / 2::tinyint; 32 | SELECT 2::integer / 2::tinyint; 33 | SELECT 2::bigint / 2::tinyint; 34 | SELECT 2::tinyint * 2::smallint; 35 | SELECT 2::tinyint * 2::integer; 36 | SELECT 2::tinyint * 2::bigint; 37 | SELECT 2::tinyint / 2::smallint; 38 | SELECT 2::tinyint / 2::integer; 39 | SELECT 2::tinyint / 2::bigint; 40 | 41 | SELECT MAX(val), MIN(val), AVG(val), SUM(val) FROM (VALUES('1'::tinyint),('2'),('5'),('10')) AS s(val); 42 | 43 | CREATE TABLE t_tinyint (vals tinyint[]); 44 | INSERT INTO t_tinyint VALUES('{0,0,0,1,2,3,0}'),('{1,2,100,127,-126}'::tinyint[]); 45 | CREATE INDEX t_tinyint_gin ON t_tinyint USING gin(vals); 46 | 47 | SELECT 128::tinyint; 48 | SELECT 16::tinyint * 16::tinyint; 49 | SELECT 127::tinyint * 32767::smallint; 50 | SELECT 16::tinyint / 0; 51 | SELECT (1::bigint << 63) * 2::tinyint; 52 | -------------------------------------------------------------------------------- /tinyint.c: -------------------------------------------------------------------------------- 1 | #include "postgres.h" 2 | 3 | #include 4 | #include 5 | 6 | #include "access/hash.h" 7 | #include "catalog/pg_type.h" 8 | #include "libpq/pqformat.h" 9 | #include "utils/array.h" 10 | #include "utils/builtins.h" 11 | #include "tinyint.h" 12 | 13 | #define SAMESIGN(a,b) (((a) < 0) == ((b) < 0)) 14 | 15 | PG_MODULE_MAGIC; 16 | 17 | PG_FUNCTION_INFO_V1(tinyint_in); 18 | PG_FUNCTION_INFO_V1(tinyint_out); 19 | PG_FUNCTION_INFO_V1(tinyint_recv); 20 | PG_FUNCTION_INFO_V1(tinyint_send); 21 | 22 | PG_FUNCTION_INFO_V1(tinyint_to_i2); 23 | PG_FUNCTION_INFO_V1(i2_to_tinyint); 24 | PG_FUNCTION_INFO_V1(tinyint_to_i4); 25 | PG_FUNCTION_INFO_V1(i4_to_tinyint); 26 | PG_FUNCTION_INFO_V1(tinyint_to_i8); 27 | PG_FUNCTION_INFO_V1(i8_to_tinyint); 28 | PG_FUNCTION_INFO_V1(tinyint_to_bool); 29 | PG_FUNCTION_INFO_V1(bool_to_tinyint); 30 | 31 | PG_FUNCTION_INFO_V1(tinyint_eq); 32 | PG_FUNCTION_INFO_V1(tinyint_ne); 33 | PG_FUNCTION_INFO_V1(tinyint_lt); 34 | PG_FUNCTION_INFO_V1(tinyint_le); 35 | PG_FUNCTION_INFO_V1(tinyint_gt); 36 | PG_FUNCTION_INFO_V1(tinyint_ge); 37 | 38 | PG_FUNCTION_INFO_V1(tinyint_i2_eq); 39 | PG_FUNCTION_INFO_V1(tinyint_i2_ne); 40 | PG_FUNCTION_INFO_V1(tinyint_i2_lt); 41 | PG_FUNCTION_INFO_V1(tinyint_i2_le); 42 | PG_FUNCTION_INFO_V1(tinyint_i2_gt); 43 | PG_FUNCTION_INFO_V1(tinyint_i2_ge); 44 | 45 | PG_FUNCTION_INFO_V1(tinyint_i4_eq); 46 | PG_FUNCTION_INFO_V1(tinyint_i4_ne); 47 | PG_FUNCTION_INFO_V1(tinyint_i4_lt); 48 | PG_FUNCTION_INFO_V1(tinyint_i4_le); 49 | PG_FUNCTION_INFO_V1(tinyint_i4_gt); 50 | PG_FUNCTION_INFO_V1(tinyint_i4_ge); 51 | 52 | PG_FUNCTION_INFO_V1(tinyint_i8_eq); 53 | PG_FUNCTION_INFO_V1(tinyint_i8_ne); 54 | PG_FUNCTION_INFO_V1(tinyint_i8_lt); 55 | PG_FUNCTION_INFO_V1(tinyint_i8_le); 56 | PG_FUNCTION_INFO_V1(tinyint_i8_gt); 57 | PG_FUNCTION_INFO_V1(tinyint_i8_ge); 58 | 59 | PG_FUNCTION_INFO_V1(i2_tinyint_eq); 60 | PG_FUNCTION_INFO_V1(i2_tinyint_ne); 61 | PG_FUNCTION_INFO_V1(i2_tinyint_lt); 62 | PG_FUNCTION_INFO_V1(i2_tinyint_le); 63 | PG_FUNCTION_INFO_V1(i2_tinyint_gt); 64 | PG_FUNCTION_INFO_V1(i2_tinyint_ge); 65 | 66 | PG_FUNCTION_INFO_V1(i4_tinyint_eq); 67 | PG_FUNCTION_INFO_V1(i4_tinyint_ne); 68 | PG_FUNCTION_INFO_V1(i4_tinyint_lt); 69 | PG_FUNCTION_INFO_V1(i4_tinyint_le); 70 | PG_FUNCTION_INFO_V1(i4_tinyint_gt); 71 | PG_FUNCTION_INFO_V1(i4_tinyint_ge); 72 | 73 | PG_FUNCTION_INFO_V1(i8_tinyint_eq); 74 | PG_FUNCTION_INFO_V1(i8_tinyint_ne); 75 | PG_FUNCTION_INFO_V1(i8_tinyint_lt); 76 | PG_FUNCTION_INFO_V1(i8_tinyint_le); 77 | PG_FUNCTION_INFO_V1(i8_tinyint_gt); 78 | PG_FUNCTION_INFO_V1(i8_tinyint_ge); 79 | 80 | PG_FUNCTION_INFO_V1(tinyint_um); 81 | PG_FUNCTION_INFO_V1(tinyint_up); 82 | PG_FUNCTION_INFO_V1(tinyint_pl); 83 | PG_FUNCTION_INFO_V1(tinyint_mi); 84 | PG_FUNCTION_INFO_V1(tinyint_mul); 85 | PG_FUNCTION_INFO_V1(tinyint_div); 86 | PG_FUNCTION_INFO_V1(tinyint_inc); 87 | 88 | PG_FUNCTION_INFO_V1(tinyint_i2_pl); 89 | PG_FUNCTION_INFO_V1(tinyint_i2_mi); 90 | PG_FUNCTION_INFO_V1(tinyint_i2_mul); 91 | PG_FUNCTION_INFO_V1(tinyint_i2_div); 92 | 93 | PG_FUNCTION_INFO_V1(tinyint_i4_pl); 94 | PG_FUNCTION_INFO_V1(tinyint_i4_mi); 95 | PG_FUNCTION_INFO_V1(tinyint_i4_mul); 96 | PG_FUNCTION_INFO_V1(tinyint_i4_div); 97 | 98 | PG_FUNCTION_INFO_V1(tinyint_i8_pl); 99 | PG_FUNCTION_INFO_V1(tinyint_i8_mi); 100 | PG_FUNCTION_INFO_V1(tinyint_i8_mul); 101 | PG_FUNCTION_INFO_V1(tinyint_i8_div); 102 | 103 | PG_FUNCTION_INFO_V1(i2_tinyint_pl); 104 | PG_FUNCTION_INFO_V1(i2_tinyint_mi); 105 | PG_FUNCTION_INFO_V1(i2_tinyint_mul); 106 | PG_FUNCTION_INFO_V1(i2_tinyint_div); 107 | 108 | PG_FUNCTION_INFO_V1(i4_tinyint_pl); 109 | PG_FUNCTION_INFO_V1(i4_tinyint_mi); 110 | PG_FUNCTION_INFO_V1(i4_tinyint_mul); 111 | PG_FUNCTION_INFO_V1(i4_tinyint_div); 112 | 113 | PG_FUNCTION_INFO_V1(i8_tinyint_pl); 114 | PG_FUNCTION_INFO_V1(i8_tinyint_mi); 115 | PG_FUNCTION_INFO_V1(i8_tinyint_mul); 116 | PG_FUNCTION_INFO_V1(i8_tinyint_div); 117 | 118 | PG_FUNCTION_INFO_V1(tinyint_mod); 119 | PG_FUNCTION_INFO_V1(tinyint_abs); 120 | PG_FUNCTION_INFO_V1(tinyint_larger); 121 | PG_FUNCTION_INFO_V1(tinyint_smaller); 122 | PG_FUNCTION_INFO_V1(tinyint_and); 123 | PG_FUNCTION_INFO_V1(tinyint_or); 124 | PG_FUNCTION_INFO_V1(tinyint_xor); 125 | PG_FUNCTION_INFO_V1(tinyint_shl); 126 | PG_FUNCTION_INFO_V1(tinyint_shr); 127 | PG_FUNCTION_INFO_V1(tinyint_not); 128 | 129 | PG_FUNCTION_INFO_V1(bt_tinyint_cmp); 130 | PG_FUNCTION_INFO_V1(bt_tinyint_i2_cmp); 131 | PG_FUNCTION_INFO_V1(bt_tinyint_i4_cmp); 132 | PG_FUNCTION_INFO_V1(bt_tinyint_i8_cmp); 133 | PG_FUNCTION_INFO_V1(bt_i2_tinyint_cmp); 134 | PG_FUNCTION_INFO_V1(bt_i4_tinyint_cmp); 135 | PG_FUNCTION_INFO_V1(bt_i8_tinyint_cmp); 136 | 137 | PG_FUNCTION_INFO_V1(hash_tinyint); 138 | 139 | PG_FUNCTION_INFO_V1(tinyint_sum); 140 | PG_FUNCTION_INFO_V1(tinyint_avg_accum); 141 | 142 | /***************************************************************************** 143 | * USER I/O ROUTINES * 144 | *****************************************************************************/ 145 | 146 | /* 147 | * tinyint_in - converts "num" to tinyint 148 | */ 149 | Datum 150 | tinyint_in(PG_FUNCTION_ARGS) 151 | { 152 | char *num = PG_GETARG_CSTRING(0); 153 | 154 | PG_RETURN_TINYINT(pg_atoi(num, sizeof(tinyint), '\0')); 155 | } 156 | 157 | /* 158 | * tinyint_out - converts tinyint to "num" 159 | */ 160 | Datum 161 | tinyint_out(PG_FUNCTION_ARGS) 162 | { 163 | tinyint arg1 = PG_GETARG_TINYINT(0); 164 | char *result = (char *) palloc(5); /* sign, 3 digits, '\0' */ 165 | 166 | pg_itoa(arg1, result); 167 | PG_RETURN_CSTRING(result); 168 | } 169 | 170 | /* 171 | * tinyint_recv - converts external binary format to tinyint 172 | */ 173 | Datum 174 | tinyint_recv(PG_FUNCTION_ARGS) 175 | { 176 | StringInfo buf = (StringInfo) PG_GETARG_POINTER(0); 177 | 178 | PG_RETURN_TINYINT((tinyint) pq_getmsgint(buf, sizeof(tinyint))); 179 | } 180 | 181 | /* 182 | * tinyint_send - converts tinyint to binary format 183 | */ 184 | Datum 185 | tinyint_send(PG_FUNCTION_ARGS) 186 | { 187 | tinyint arg1 = PG_GETARG_TINYINT(0); 188 | StringInfoData buf; 189 | 190 | pq_begintypsend(&buf); 191 | pq_sendint(&buf, arg1, sizeof(tinyint)); 192 | PG_RETURN_BYTEA_P(pq_endtypsend(&buf)); 193 | } 194 | 195 | /* 196 | * =================== 197 | * CONVERSION ROUTINES 198 | * =================== 199 | */ 200 | 201 | Datum 202 | tinyint_to_i2(PG_FUNCTION_ARGS) 203 | { 204 | tinyint arg1 = PG_GETARG_TINYINT(0); 205 | 206 | PG_RETURN_INT16((int16) arg1); 207 | } 208 | 209 | Datum 210 | i2_to_tinyint(PG_FUNCTION_ARGS) 211 | { 212 | int16 arg1 = PG_GETARG_INT16(0); 213 | 214 | if (arg1 < SCHAR_MIN || arg1 > SCHAR_MAX) 215 | ereport(ERROR, 216 | (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), 217 | errmsg("tinyint out of range"))); 218 | 219 | PG_RETURN_TINYINT((tinyint) arg1); 220 | } 221 | 222 | Datum 223 | tinyint_to_i4(PG_FUNCTION_ARGS) 224 | { 225 | tinyint arg1 = PG_GETARG_TINYINT(0); 226 | 227 | PG_RETURN_INT32((int32) arg1); 228 | } 229 | 230 | Datum 231 | i4_to_tinyint(PG_FUNCTION_ARGS) 232 | { 233 | int32 arg1 = PG_GETARG_INT32(0); 234 | 235 | if (arg1 < SCHAR_MIN || arg1 > SCHAR_MAX) 236 | ereport(ERROR, 237 | (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), 238 | errmsg("tinyint out of range"))); 239 | 240 | PG_RETURN_TINYINT((tinyint) arg1); 241 | } 242 | 243 | Datum 244 | tinyint_to_i8(PG_FUNCTION_ARGS) 245 | { 246 | tinyint arg1 = PG_GETARG_TINYINT(0); 247 | 248 | PG_RETURN_INT64((int64) arg1); 249 | } 250 | 251 | Datum 252 | i8_to_tinyint(PG_FUNCTION_ARGS) 253 | { 254 | int64 arg1 = PG_GETARG_INT64(0); 255 | tinyint result; 256 | 257 | result = (tinyint) arg1; 258 | 259 | if ((int64) result != arg1) 260 | ereport(ERROR, 261 | (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), 262 | errmsg("tinyint out of range"))); 263 | 264 | PG_RETURN_TINYINT(result); 265 | } 266 | 267 | Datum 268 | tinyint_to_bool(PG_FUNCTION_ARGS) 269 | { 270 | if (PG_GETARG_TINYINT(0) == 0) 271 | PG_RETURN_BOOL(false); 272 | else 273 | PG_RETURN_BOOL(true); 274 | } 275 | 276 | Datum 277 | bool_to_tinyint(PG_FUNCTION_ARGS) 278 | { 279 | if (PG_GETARG_BOOL(0) == false) 280 | PG_RETURN_TINYINT(0); 281 | else 282 | PG_RETURN_TINYINT(1); 283 | } 284 | 285 | /* 286 | * ============================ 287 | * COMPARISON OPERATOR ROUTINES 288 | * ============================ 289 | */ 290 | 291 | Datum 292 | tinyint_eq(PG_FUNCTION_ARGS) 293 | { 294 | PG_RETURN_BOOL(PG_GETARG_TINYINT(0) == PG_GETARG_TINYINT(1)); 295 | } 296 | 297 | Datum 298 | tinyint_ne(PG_FUNCTION_ARGS) 299 | { 300 | PG_RETURN_BOOL(PG_GETARG_TINYINT(0) != PG_GETARG_TINYINT(1)); 301 | } 302 | 303 | Datum 304 | tinyint_lt(PG_FUNCTION_ARGS) 305 | { 306 | PG_RETURN_BOOL(PG_GETARG_TINYINT(0) < PG_GETARG_TINYINT(1)); 307 | } 308 | 309 | Datum 310 | tinyint_le(PG_FUNCTION_ARGS) 311 | { 312 | PG_RETURN_BOOL(PG_GETARG_TINYINT(0) <= PG_GETARG_TINYINT(1)); 313 | } 314 | 315 | Datum 316 | tinyint_gt(PG_FUNCTION_ARGS) 317 | { 318 | PG_RETURN_BOOL(PG_GETARG_TINYINT(0) > PG_GETARG_TINYINT(1)); 319 | } 320 | 321 | Datum 322 | tinyint_ge(PG_FUNCTION_ARGS) 323 | { 324 | PG_RETURN_BOOL(PG_GETARG_TINYINT(0) >= PG_GETARG_TINYINT(1)); 325 | } 326 | 327 | Datum 328 | tinyint_i2_eq(PG_FUNCTION_ARGS) 329 | { 330 | PG_RETURN_BOOL(PG_GETARG_TINYINT(0) == PG_GETARG_INT16(1)); 331 | } 332 | 333 | Datum 334 | tinyint_i2_ne(PG_FUNCTION_ARGS) 335 | { 336 | PG_RETURN_BOOL(PG_GETARG_TINYINT(0) != PG_GETARG_INT16(1)); 337 | } 338 | 339 | Datum 340 | tinyint_i2_lt(PG_FUNCTION_ARGS) 341 | { 342 | PG_RETURN_BOOL(PG_GETARG_TINYINT(0) < PG_GETARG_INT16(1)); 343 | } 344 | 345 | Datum 346 | tinyint_i2_le(PG_FUNCTION_ARGS) 347 | { 348 | PG_RETURN_BOOL(PG_GETARG_TINYINT(0) <= PG_GETARG_INT16(1)); 349 | } 350 | 351 | Datum 352 | tinyint_i2_gt(PG_FUNCTION_ARGS) 353 | { 354 | PG_RETURN_BOOL(PG_GETARG_TINYINT(0) > PG_GETARG_INT16(1)); 355 | } 356 | 357 | Datum 358 | tinyint_i2_ge(PG_FUNCTION_ARGS) 359 | { 360 | PG_RETURN_BOOL(PG_GETARG_TINYINT(0) >= PG_GETARG_INT16(1)); 361 | } 362 | 363 | Datum 364 | tinyint_i4_eq(PG_FUNCTION_ARGS) 365 | { 366 | PG_RETURN_BOOL(PG_GETARG_TINYINT(0) == PG_GETARG_INT32(1)); 367 | } 368 | 369 | Datum 370 | tinyint_i4_ne(PG_FUNCTION_ARGS) 371 | { 372 | PG_RETURN_BOOL(PG_GETARG_TINYINT(0) != PG_GETARG_INT32(1)); 373 | } 374 | 375 | Datum 376 | tinyint_i4_lt(PG_FUNCTION_ARGS) 377 | { 378 | PG_RETURN_BOOL(PG_GETARG_TINYINT(0) < PG_GETARG_INT32(1)); 379 | } 380 | 381 | Datum 382 | tinyint_i4_le(PG_FUNCTION_ARGS) 383 | { 384 | PG_RETURN_BOOL(PG_GETARG_TINYINT(0) <= PG_GETARG_INT32(1)); 385 | } 386 | 387 | Datum 388 | tinyint_i4_gt(PG_FUNCTION_ARGS) 389 | { 390 | PG_RETURN_BOOL(PG_GETARG_TINYINT(0) > PG_GETARG_INT32(1)); 391 | } 392 | 393 | Datum 394 | tinyint_i4_ge(PG_FUNCTION_ARGS) 395 | { 396 | PG_RETURN_BOOL(PG_GETARG_TINYINT(0) >= PG_GETARG_INT32(1)); 397 | } 398 | 399 | Datum 400 | tinyint_i8_eq(PG_FUNCTION_ARGS) 401 | { 402 | PG_RETURN_BOOL(PG_GETARG_TINYINT(0) == PG_GETARG_INT64(1)); 403 | } 404 | 405 | Datum 406 | tinyint_i8_ne(PG_FUNCTION_ARGS) 407 | { 408 | PG_RETURN_BOOL(PG_GETARG_TINYINT(0) != PG_GETARG_INT64(1)); 409 | } 410 | 411 | Datum 412 | tinyint_i8_lt(PG_FUNCTION_ARGS) 413 | { 414 | PG_RETURN_BOOL(PG_GETARG_TINYINT(0) < PG_GETARG_INT64(1)); 415 | } 416 | 417 | Datum 418 | tinyint_i8_le(PG_FUNCTION_ARGS) 419 | { 420 | PG_RETURN_BOOL(PG_GETARG_TINYINT(0) <= PG_GETARG_INT64(1)); 421 | } 422 | 423 | Datum 424 | tinyint_i8_gt(PG_FUNCTION_ARGS) 425 | { 426 | PG_RETURN_BOOL(PG_GETARG_TINYINT(0) > PG_GETARG_INT64(1)); 427 | } 428 | 429 | Datum 430 | tinyint_i8_ge(PG_FUNCTION_ARGS) 431 | { 432 | PG_RETURN_BOOL(PG_GETARG_TINYINT(0) >= PG_GETARG_INT64(1)); 433 | } 434 | 435 | Datum 436 | i2_tinyint_eq(PG_FUNCTION_ARGS) 437 | { 438 | PG_RETURN_BOOL(PG_GETARG_INT16(0) == PG_GETARG_TINYINT(1)); 439 | } 440 | 441 | Datum 442 | i2_tinyint_ne(PG_FUNCTION_ARGS) 443 | { 444 | PG_RETURN_BOOL(PG_GETARG_INT16(0) != PG_GETARG_TINYINT(1)); 445 | } 446 | 447 | Datum 448 | i2_tinyint_lt(PG_FUNCTION_ARGS) 449 | { 450 | PG_RETURN_BOOL(PG_GETARG_INT16(0) < PG_GETARG_TINYINT(1)); 451 | } 452 | 453 | Datum 454 | i2_tinyint_le(PG_FUNCTION_ARGS) 455 | { 456 | PG_RETURN_BOOL(PG_GETARG_INT16(0) <= PG_GETARG_TINYINT(1)); 457 | } 458 | 459 | Datum 460 | i2_tinyint_gt(PG_FUNCTION_ARGS) 461 | { 462 | PG_RETURN_BOOL(PG_GETARG_INT16(0) > PG_GETARG_TINYINT(1)); 463 | } 464 | 465 | Datum 466 | i2_tinyint_ge(PG_FUNCTION_ARGS) 467 | { 468 | PG_RETURN_BOOL(PG_GETARG_INT16(0) >= PG_GETARG_TINYINT(1)); 469 | } 470 | 471 | Datum 472 | i4_tinyint_eq(PG_FUNCTION_ARGS) 473 | { 474 | PG_RETURN_BOOL(PG_GETARG_INT32(0) == PG_GETARG_TINYINT(1)); 475 | } 476 | 477 | Datum 478 | i4_tinyint_ne(PG_FUNCTION_ARGS) 479 | { 480 | PG_RETURN_BOOL(PG_GETARG_INT32(0) != PG_GETARG_TINYINT(1)); 481 | } 482 | 483 | Datum 484 | i4_tinyint_lt(PG_FUNCTION_ARGS) 485 | { 486 | PG_RETURN_BOOL(PG_GETARG_INT32(0) < PG_GETARG_TINYINT(1)); 487 | } 488 | 489 | Datum 490 | i4_tinyint_le(PG_FUNCTION_ARGS) 491 | { 492 | PG_RETURN_BOOL(PG_GETARG_INT32(0) <= PG_GETARG_TINYINT(1)); 493 | } 494 | 495 | Datum 496 | i4_tinyint_gt(PG_FUNCTION_ARGS) 497 | { 498 | PG_RETURN_BOOL(PG_GETARG_INT32(0) > PG_GETARG_TINYINT(1)); 499 | } 500 | 501 | Datum 502 | i4_tinyint_ge(PG_FUNCTION_ARGS) 503 | { 504 | PG_RETURN_BOOL(PG_GETARG_INT32(0) >= PG_GETARG_TINYINT(1)); 505 | } 506 | 507 | Datum 508 | i8_tinyint_eq(PG_FUNCTION_ARGS) 509 | { 510 | PG_RETURN_BOOL(PG_GETARG_INT64(0) == PG_GETARG_TINYINT(1)); 511 | } 512 | 513 | Datum 514 | i8_tinyint_ne(PG_FUNCTION_ARGS) 515 | { 516 | PG_RETURN_BOOL(PG_GETARG_INT64(0) != PG_GETARG_TINYINT(1)); 517 | } 518 | 519 | Datum 520 | i8_tinyint_lt(PG_FUNCTION_ARGS) 521 | { 522 | PG_RETURN_BOOL(PG_GETARG_INT64(0) < PG_GETARG_TINYINT(1)); 523 | } 524 | 525 | Datum 526 | i8_tinyint_le(PG_FUNCTION_ARGS) 527 | { 528 | PG_RETURN_BOOL(PG_GETARG_INT64(0) <= PG_GETARG_TINYINT(1)); 529 | } 530 | 531 | Datum 532 | i8_tinyint_gt(PG_FUNCTION_ARGS) 533 | { 534 | PG_RETURN_BOOL(PG_GETARG_INT64(0) > PG_GETARG_TINYINT(1)); 535 | } 536 | 537 | Datum 538 | i8_tinyint_ge(PG_FUNCTION_ARGS) 539 | { 540 | PG_RETURN_BOOL(PG_GETARG_INT64(0) >= PG_GETARG_TINYINT(1)); 541 | } 542 | 543 | /* 544 | * pl - returns arg1 + arg2 545 | * mi - returns arg1 - arg2 546 | * mul - returns arg1 * arg2 547 | * div - returns arg1 / arg2 548 | */ 549 | 550 | Datum 551 | tinyint_um(PG_FUNCTION_ARGS) 552 | { 553 | tinyint arg = PG_GETARG_TINYINT(0); 554 | tinyint result; 555 | 556 | result = -arg; 557 | 558 | if (arg != 0 && SAMESIGN(result, arg)) 559 | ereport(ERROR, 560 | (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), 561 | errmsg("tinyint out of range"))); 562 | PG_RETURN_TINYINT(result); 563 | } 564 | 565 | Datum 566 | tinyint_up(PG_FUNCTION_ARGS) 567 | { 568 | PG_RETURN_TINYINT(PG_GETARG_TINYINT(0)); 569 | } 570 | 571 | Datum 572 | tinyint_pl(PG_FUNCTION_ARGS) 573 | { 574 | tinyint arg1 = PG_GETARG_TINYINT(0); 575 | tinyint arg2 = PG_GETARG_TINYINT(1); 576 | tinyint result; 577 | 578 | result = arg1 + arg2; 579 | 580 | /* 581 | * Overflow check. If the inputs are of different signs then their sum 582 | * cannot overflow. If the inputs are of the same sign, their sum had 583 | * better be that sign too. 584 | */ 585 | if (SAMESIGN(arg1, arg2) && !SAMESIGN(result, arg1)) 586 | ereport(ERROR, 587 | (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), 588 | errmsg("tinyint out of range"))); 589 | PG_RETURN_TINYINT(result); 590 | } 591 | 592 | Datum 593 | tinyint_mi(PG_FUNCTION_ARGS) 594 | { 595 | tinyint arg1 = PG_GETARG_TINYINT(0); 596 | tinyint arg2 = PG_GETARG_TINYINT(1); 597 | tinyint result; 598 | 599 | result = arg1 - arg2; 600 | 601 | /* 602 | * Overflow check. If the inputs are of different signs then their sum 603 | * cannot overflow. If the inputs are of the same sign, their sum had 604 | * better be that sign too. 605 | */ 606 | if (!SAMESIGN(arg1, arg2) && !SAMESIGN(result, arg1)) 607 | ereport(ERROR, 608 | (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), 609 | errmsg("tinyint out of range"))); 610 | PG_RETURN_TINYINT(result); 611 | } 612 | 613 | Datum 614 | tinyint_mul(PG_FUNCTION_ARGS) 615 | { 616 | tinyint arg1 = PG_GETARG_TINYINT(0); 617 | tinyint arg2 = PG_GETARG_TINYINT(1); 618 | tinyint result; 619 | 620 | result = arg1 * arg2; 621 | 622 | /* 623 | * Overflow check. We basically check to see if result / arg2 gives arg1 624 | * again. There are two cases where this fails: arg2 = 0 (which cannot 625 | * overflow) and arg1 = INT_MIN, arg2 = -1 (where the division itself will 626 | * overflow and thus incorrectly match). 627 | * 628 | * Since the division is likely much more expensive than the actual 629 | * multiplication, we'd like to skip it where possible. The best bang for 630 | * the buck seems to be to check whether both inputs are in the 4bit 631 | * range; if so, no overflow is possible. 632 | */ 633 | if (!(arg1 >= (tinyint) -14 && arg1 <= (tinyint) 15 && 634 | arg2 >= (tinyint) -14 && arg2 <= (tinyint) 15) && 635 | arg2 != 0 && 636 | (result / arg2 != arg1 || (arg2 == -1 && arg1 < 0 && result < 0))) 637 | ereport(ERROR, 638 | (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), 639 | errmsg("tinyint out of range"))); 640 | PG_RETURN_TINYINT(result); 641 | } 642 | 643 | Datum 644 | tinyint_div(PG_FUNCTION_ARGS) 645 | { 646 | tinyint arg1 = PG_GETARG_TINYINT(0); 647 | tinyint arg2 = PG_GETARG_TINYINT(1); 648 | tinyint result; 649 | 650 | if (arg2 == 0) 651 | ereport(ERROR, 652 | (errcode(ERRCODE_DIVISION_BY_ZERO), 653 | errmsg("division by zero"))); 654 | 655 | result = arg1 / arg2; 656 | 657 | /* 658 | * Overflow check. The only possible overflow case is for arg1 = INT_MIN, 659 | * arg2 = -1, where the correct result is -INT_MIN, which can't be 660 | * represented on a two's-complement machine. Most machines produce 661 | * INT_MIN but it seems some produce zero. 662 | */ 663 | if (arg2 == -1 && arg1 < 0 && result <= 0) 664 | ereport(ERROR, 665 | (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), 666 | errmsg("tinyint out of range"))); 667 | PG_RETURN_INT32(result); 668 | } 669 | 670 | Datum 671 | tinyint_inc(PG_FUNCTION_ARGS) 672 | { 673 | tinyint arg = PG_GETARG_TINYINT(0); 674 | tinyint result; 675 | 676 | result = arg + 1; 677 | /* Overflow check */ 678 | if (arg > 0 && result < 0) 679 | ereport(ERROR, 680 | (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), 681 | errmsg("tinyint out of range"))); 682 | 683 | PG_RETURN_TINYINT(result); 684 | } 685 | 686 | Datum 687 | tinyint_i2_pl(PG_FUNCTION_ARGS) 688 | { 689 | tinyint arg1 = PG_GETARG_TINYINT(0); 690 | int16 arg2 = PG_GETARG_INT16(1); 691 | int16 result; 692 | 693 | result = arg1 + arg2; 694 | 695 | /* 696 | * Overflow check. If the inputs are of different signs then their sum 697 | * cannot overflow. If the inputs are of the same sign, their sum had 698 | * better be that sign too. 699 | */ 700 | if (SAMESIGN(arg1, arg2) && !SAMESIGN(result, arg1)) 701 | ereport(ERROR, 702 | (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), 703 | errmsg("smallint out of range"))); 704 | PG_RETURN_INT16(result); 705 | } 706 | 707 | Datum 708 | tinyint_i2_mi(PG_FUNCTION_ARGS) 709 | { 710 | tinyint arg1 = PG_GETARG_TINYINT(0); 711 | int16 arg2 = PG_GETARG_INT16(1); 712 | int16 result; 713 | 714 | result = arg1 - arg2; 715 | 716 | /* 717 | * Overflow check. If the inputs are of the same sign then their 718 | * difference cannot overflow. If they are of different signs then the 719 | * result should be of the same sign as the first input. 720 | */ 721 | if (!SAMESIGN(arg1, arg2) && !SAMESIGN(result, arg1)) 722 | ereport(ERROR, 723 | (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), 724 | errmsg("smallint out of range"))); 725 | PG_RETURN_INT16(result); 726 | } 727 | 728 | Datum 729 | tinyint_i2_mul(PG_FUNCTION_ARGS) 730 | { 731 | tinyint arg1 = PG_GETARG_TINYINT(0); 732 | int16 arg2 = PG_GETARG_INT16(1); 733 | int16 result; 734 | 735 | result = arg1 * arg2; 736 | 737 | /* 738 | * Overflow check. We basically check to see if result / arg2 gives arg1 739 | * again. There is one case where this fails: arg2 = 0 (which cannot 740 | * overflow). 741 | * 742 | * Since the division is likely much more expensive than the actual 743 | * multiplication, we'd like to skip it where possible. The best bang for 744 | * the buck seems to be to check whether both inputs are in the tinyint 745 | * range; if so, no overflow is possible. 746 | */ 747 | if (!(arg2 >= (int16) SCHAR_MIN && arg2 <= (int16) SCHAR_MAX) && 748 | result / arg2 != arg1) 749 | ereport(ERROR, 750 | (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), 751 | errmsg("smallint out of range"))); 752 | PG_RETURN_INT16(result); 753 | } 754 | 755 | Datum 756 | tinyint_i2_div(PG_FUNCTION_ARGS) 757 | { 758 | tinyint arg1 = PG_GETARG_TINYINT(0); 759 | int16 arg2 = PG_GETARG_INT16(1); 760 | 761 | if (arg2 == 0) 762 | ereport(ERROR, 763 | (errcode(ERRCODE_DIVISION_BY_ZERO), 764 | errmsg("division by zero"))); 765 | /* No overflow is possible */ 766 | PG_RETURN_INT16((int16) arg1 / arg2); 767 | } 768 | 769 | Datum 770 | tinyint_i4_pl(PG_FUNCTION_ARGS) 771 | { 772 | tinyint arg1 = PG_GETARG_TINYINT(0); 773 | int32 arg2 = PG_GETARG_INT32(1); 774 | int32 result; 775 | 776 | result = arg1 + arg2; 777 | 778 | /* 779 | * Overflow check. If the inputs are of different signs then their sum 780 | * cannot overflow. If the inputs are of the same sign, their sum had 781 | * better be that sign too. 782 | */ 783 | if (SAMESIGN(arg1, arg2) && !SAMESIGN(result, arg1)) 784 | ereport(ERROR, 785 | (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), 786 | errmsg("integer out of range"))); 787 | PG_RETURN_INT32(result); 788 | } 789 | 790 | Datum 791 | tinyint_i4_mi(PG_FUNCTION_ARGS) 792 | { 793 | tinyint arg1 = PG_GETARG_TINYINT(0); 794 | int32 arg2 = PG_GETARG_INT32(1); 795 | int32 result; 796 | 797 | result = arg1 - arg2; 798 | 799 | /* 800 | * Overflow check. If the inputs are of the same sign then their 801 | * difference cannot overflow. If they are of different signs then the 802 | * result should be of the same sign as the first input. 803 | */ 804 | if (!SAMESIGN(arg1, arg2) && !SAMESIGN(result, arg1)) 805 | ereport(ERROR, 806 | (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), 807 | errmsg("integer out of range"))); 808 | PG_RETURN_INT32(result); 809 | } 810 | 811 | Datum 812 | tinyint_i4_mul(PG_FUNCTION_ARGS) 813 | { 814 | tinyint arg1 = PG_GETARG_TINYINT(0); 815 | int32 arg2 = PG_GETARG_INT32(1); 816 | int32 result; 817 | 818 | result = arg1 * arg2; 819 | 820 | /* 821 | * Overflow check. We basically check to see if result / arg2 gives arg1 822 | * again. There is one case where this fails: arg2 = 0 (which cannot 823 | * overflow). 824 | * 825 | * Since the division is likely much more expensive than the actual 826 | * multiplication, we'd like to skip it where possible. The best bang for 827 | * the buck seems to be to check whether both inputs are in the int16 828 | * range; if so, no overflow is possible. 829 | */ 830 | if (!(arg2 >= (int32) SHRT_MIN && arg2 <= (int32) SHRT_MAX) && 831 | result / arg2 != arg1) 832 | ereport(ERROR, 833 | (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), 834 | errmsg("integer out of range"))); 835 | PG_RETURN_INT32(result); 836 | } 837 | 838 | Datum 839 | tinyint_i4_div(PG_FUNCTION_ARGS) 840 | { 841 | tinyint arg1 = PG_GETARG_TINYINT(0); 842 | int32 arg2 = PG_GETARG_INT32(1); 843 | 844 | if (arg2 == 0) 845 | ereport(ERROR, 846 | (errcode(ERRCODE_DIVISION_BY_ZERO), 847 | errmsg("division by zero"))); 848 | /* No overflow is possible */ 849 | PG_RETURN_INT32((int32) arg1 / arg2); 850 | } 851 | 852 | Datum 853 | tinyint_i8_pl(PG_FUNCTION_ARGS) 854 | { 855 | tinyint arg1 = PG_GETARG_TINYINT(0); 856 | int64 arg2 = PG_GETARG_INT64(1); 857 | int64 result; 858 | 859 | result = arg1 + arg2; 860 | 861 | /* 862 | * Overflow check. If the inputs are of different signs then their sum 863 | * cannot overflow. If the inputs are of the same sign, their sum had 864 | * better be that sign too. 865 | */ 866 | if (SAMESIGN(arg1, arg2) && !SAMESIGN(result, arg1)) 867 | ereport(ERROR, 868 | (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), 869 | errmsg("bigint out of range"))); 870 | PG_RETURN_INT64(result); 871 | } 872 | 873 | Datum 874 | tinyint_i8_mi(PG_FUNCTION_ARGS) 875 | { 876 | tinyint arg1 = PG_GETARG_TINYINT(0); 877 | int64 arg2 = PG_GETARG_INT64(1); 878 | int64 result; 879 | 880 | result = arg1 - arg2; 881 | 882 | /* 883 | * Overflow check. If the inputs are of the same sign then their 884 | * difference cannot overflow. If they are of different signs then the 885 | * result should be of the same sign as the first input. 886 | */ 887 | if (!SAMESIGN(arg1, arg2) && !SAMESIGN(result, arg1)) 888 | ereport(ERROR, 889 | (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), 890 | errmsg("bigint out of range"))); 891 | PG_RETURN_INT64(result); 892 | } 893 | 894 | Datum 895 | tinyint_i8_mul(PG_FUNCTION_ARGS) 896 | { 897 | tinyint arg1 = PG_GETARG_TINYINT(0); 898 | int64 arg2 = PG_GETARG_INT64(1); 899 | int64 result; 900 | 901 | result = arg1 * arg2; 902 | 903 | /* 904 | * Overflow check. We basically check to see if result / arg2 gives arg1 905 | * again. There is one case where this fails: arg2 = 0 (which cannot 906 | * overflow). 907 | * 908 | * Since the division is likely much more expensive than the actual 909 | * multiplication, we'd like to skip it where possible. The best bang for 910 | * the buck seems to be to check whether both inputs are in the tinyint 911 | * range; if so, no overflow is possible. 912 | */ 913 | if (arg2 != (int64) ((int32) arg2) && 914 | result / arg2 != arg1) 915 | ereport(ERROR, 916 | (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), 917 | errmsg("bigint out of range"))); 918 | PG_RETURN_INT64(result); 919 | } 920 | 921 | Datum 922 | tinyint_i8_div(PG_FUNCTION_ARGS) 923 | { 924 | tinyint arg1 = PG_GETARG_TINYINT(0); 925 | int64 arg2 = PG_GETARG_INT64(1); 926 | 927 | if (arg2 == 0) 928 | ereport(ERROR, 929 | (errcode(ERRCODE_DIVISION_BY_ZERO), 930 | errmsg("division by zero"))); 931 | /* No overflow is possible */ 932 | PG_RETURN_INT64((int64) arg1 / arg2); 933 | } 934 | 935 | Datum 936 | i2_tinyint_pl(PG_FUNCTION_ARGS) 937 | { 938 | int16 arg1 = PG_GETARG_INT16(0); 939 | tinyint arg2 = PG_GETARG_TINYINT(1); 940 | int16 result; 941 | 942 | result = arg1 + arg2; 943 | 944 | /* 945 | * Overflow check. If the inputs are of different signs then their sum 946 | * cannot overflow. If the inputs are of the same sign, their sum had 947 | * better be that sign too. 948 | */ 949 | if (SAMESIGN(arg1, arg2) && !SAMESIGN(result, arg1)) 950 | ereport(ERROR, 951 | (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), 952 | errmsg("smallint out of range"))); 953 | PG_RETURN_INT16(result); 954 | } 955 | 956 | Datum 957 | i2_tinyint_mi(PG_FUNCTION_ARGS) 958 | { 959 | int16 arg1 = PG_GETARG_INT16(0); 960 | tinyint arg2 = PG_GETARG_TINYINT(1); 961 | int16 result; 962 | 963 | result = arg1 - arg2; 964 | 965 | /* 966 | * Overflow check. If the inputs are of the same sign then their 967 | * difference cannot overflow. If they are of different signs then the 968 | * result should be of the same sign as the first input. 969 | */ 970 | if (!SAMESIGN(arg1, arg2) && !SAMESIGN(result, arg1)) 971 | ereport(ERROR, 972 | (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), 973 | errmsg("smallint out of range"))); 974 | PG_RETURN_INT16(result); 975 | } 976 | 977 | Datum 978 | i2_tinyint_mul(PG_FUNCTION_ARGS) 979 | { 980 | int16 arg1 = PG_GETARG_INT16(0); 981 | tinyint arg2 = PG_GETARG_TINYINT(1); 982 | int16 result; 983 | 984 | result = arg1 * arg2; 985 | 986 | /* 987 | * Overflow check. We basically check to see if result / arg2 gives arg1 988 | * again. There is one case where this fails: arg2 = 0 (which cannot 989 | * overflow). 990 | * 991 | * Since the division is likely much more expensive than the actual 992 | * multiplication, we'd like to skip it where possible. The best bang for 993 | * the buck seems to be to check whether both inputs are in the tinyint 994 | * range; if so, no overflow is possible. 995 | */ 996 | if (!(arg1 >= (int16) SCHAR_MIN && arg1 <= (int16) SCHAR_MAX) && 997 | result / arg2 != arg1) 998 | ereport(ERROR, 999 | (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), 1000 | errmsg("smallint out of range"))); 1001 | PG_RETURN_INT16(result); 1002 | } 1003 | 1004 | Datum 1005 | i2_tinyint_div(PG_FUNCTION_ARGS) 1006 | { 1007 | int16 arg1 = PG_GETARG_INT16(0); 1008 | tinyint arg2 = PG_GETARG_TINYINT(1); 1009 | int16 result; 1010 | 1011 | if (arg2 == 0) 1012 | ereport(ERROR, 1013 | (errcode(ERRCODE_DIVISION_BY_ZERO), 1014 | errmsg("division by zero"))); 1015 | 1016 | result = arg1 / arg2; 1017 | 1018 | /* 1019 | * Overflow check. The only possible overflow case is for arg1 = SHRT_MIN, 1020 | * arg2 = -1, where the correct result is -INT_MIN, which can't be 1021 | * represented on a two's-complement machine. Most machines produce 1022 | * INT_MIN but it seems some produce zero. 1023 | */ 1024 | if (arg2 == -1 && arg1 < 0 && result <= 0) 1025 | ereport(ERROR, 1026 | (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), 1027 | errmsg("integer out of range"))); 1028 | PG_RETURN_INT16(result); 1029 | } 1030 | 1031 | Datum 1032 | i4_tinyint_pl(PG_FUNCTION_ARGS) 1033 | { 1034 | int32 arg1 = PG_GETARG_INT32(0); 1035 | tinyint arg2 = PG_GETARG_TINYINT(1); 1036 | int32 result; 1037 | 1038 | result = arg1 + arg2; 1039 | 1040 | /* 1041 | * Overflow check. If the inputs are of different signs then their sum 1042 | * cannot overflow. If the inputs are of the same sign, their sum had 1043 | * better be that sign too. 1044 | */ 1045 | if (SAMESIGN(arg1, arg2) && !SAMESIGN(result, arg1)) 1046 | ereport(ERROR, 1047 | (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), 1048 | errmsg("integer out of range"))); 1049 | PG_RETURN_INT32(result); 1050 | } 1051 | 1052 | Datum 1053 | i4_tinyint_mi(PG_FUNCTION_ARGS) 1054 | { 1055 | int32 arg1 = PG_GETARG_INT32(0); 1056 | tinyint arg2 = PG_GETARG_TINYINT(1); 1057 | int32 result; 1058 | 1059 | result = arg1 - arg2; 1060 | 1061 | /* 1062 | * Overflow check. If the inputs are of the same sign then their 1063 | * difference cannot overflow. If they are of different signs then the 1064 | * result should be of the same sign as the first input. 1065 | */ 1066 | if (!SAMESIGN(arg1, arg2) && !SAMESIGN(result, arg1)) 1067 | ereport(ERROR, 1068 | (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), 1069 | errmsg("integer out of range"))); 1070 | PG_RETURN_INT32(result); 1071 | } 1072 | 1073 | Datum 1074 | i4_tinyint_mul(PG_FUNCTION_ARGS) 1075 | { 1076 | int32 arg1 = PG_GETARG_INT32(0); 1077 | tinyint arg2 = PG_GETARG_TINYINT(1); 1078 | int32 result; 1079 | 1080 | result = arg1 * arg2; 1081 | 1082 | /* 1083 | * Overflow check. We basically check to see if result / arg2 gives arg1 1084 | * again. There is one case where this fails: arg2 = 0 (which cannot 1085 | * overflow). 1086 | * 1087 | * Since the division is likely much more expensive than the actual 1088 | * multiplication, we'd like to skip it where possible. The best bang for 1089 | * the buck seems to be to check whether both inputs are in the int16 1090 | * range; if so, no overflow is possible. 1091 | */ 1092 | if (!(arg1 >= (int32) SHRT_MIN && arg1 <= (int32) SHRT_MAX) && 1093 | result / arg2 != arg1) 1094 | ereport(ERROR, 1095 | (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), 1096 | errmsg("integer out of range"))); 1097 | PG_RETURN_INT32(result); 1098 | } 1099 | 1100 | Datum 1101 | i4_tinyint_div(PG_FUNCTION_ARGS) 1102 | { 1103 | int32 arg1 = PG_GETARG_INT32(0); 1104 | tinyint arg2 = PG_GETARG_TINYINT(1); 1105 | int32 result; 1106 | 1107 | if (arg2 == 0) 1108 | ereport(ERROR, 1109 | (errcode(ERRCODE_DIVISION_BY_ZERO), 1110 | errmsg("division by zero"))); 1111 | 1112 | result = arg1 / arg2; 1113 | 1114 | /* 1115 | * Overflow check. The only possible overflow case is for arg1 = INT_MIN, 1116 | * arg2 = -1, where the correct result is -INT_MIN, which can't be 1117 | * represented on a two's-complement machine. Most machines produce 1118 | * INT_MIN but it seems some produce zero. 1119 | */ 1120 | if (arg2 == -1 && arg1 < 0 && result <= 0) 1121 | ereport(ERROR, 1122 | (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), 1123 | errmsg("integer out of range"))); 1124 | PG_RETURN_INT32(result); 1125 | } 1126 | 1127 | Datum 1128 | i8_tinyint_pl(PG_FUNCTION_ARGS) 1129 | { 1130 | int64 arg1 = PG_GETARG_INT64(0); 1131 | tinyint arg2 = PG_GETARG_TINYINT(1); 1132 | int64 result; 1133 | 1134 | result = arg1 + arg2; 1135 | 1136 | /* 1137 | * Overflow check. If the inputs are of different signs then their sum 1138 | * cannot overflow. If the inputs are of the same sign, their sum had 1139 | * better be that sign too. 1140 | */ 1141 | if (SAMESIGN(arg1, arg2) && !SAMESIGN(result, arg1)) 1142 | ereport(ERROR, 1143 | (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), 1144 | errmsg("bigint out of range"))); 1145 | PG_RETURN_INT64(result); 1146 | } 1147 | 1148 | Datum 1149 | i8_tinyint_mi(PG_FUNCTION_ARGS) 1150 | { 1151 | int64 arg1 = PG_GETARG_INT64(0); 1152 | tinyint arg2 = PG_GETARG_TINYINT(1); 1153 | int64 result; 1154 | 1155 | result = arg1 - arg2; 1156 | 1157 | /* 1158 | * Overflow check. If the inputs are of the same sign then their 1159 | * difference cannot overflow. If they are of different signs then the 1160 | * result should be of the same sign as the first input. 1161 | */ 1162 | if (!SAMESIGN(arg1, arg2) && !SAMESIGN(result, arg1)) 1163 | ereport(ERROR, 1164 | (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), 1165 | errmsg("bigint out of range"))); 1166 | PG_RETURN_INT64(result); 1167 | } 1168 | 1169 | Datum 1170 | i8_tinyint_mul(PG_FUNCTION_ARGS) 1171 | { 1172 | int64 arg1 = PG_GETARG_INT64(0); 1173 | tinyint arg2 = PG_GETARG_TINYINT(1); 1174 | int64 result; 1175 | 1176 | result = arg1 * arg2; 1177 | 1178 | /* 1179 | * Overflow check. We basically check to see if result / arg2 gives arg1 1180 | * again. There is one case where this fails: arg2 = 0 (which cannot 1181 | * overflow). 1182 | * 1183 | * Since the division is likely much more expensive than the actual 1184 | * multiplication, we'd like to skip it where possible. The best bang for 1185 | * the buck seems to be to check whether both inputs are in the int32 1186 | * range; if so, no overflow is possible. 1187 | */ 1188 | if (!(arg1 >= (int64) INT_MIN && arg1 <= (int64) INT_MAX) && 1189 | result / arg2 != arg1) 1190 | ereport(ERROR, 1191 | (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), 1192 | errmsg("bigint out of range"))); 1193 | PG_RETURN_INT64(result); 1194 | } 1195 | 1196 | Datum 1197 | i8_tinyint_div(PG_FUNCTION_ARGS) 1198 | { 1199 | int64 arg1 = PG_GETARG_INT64(0); 1200 | tinyint arg2 = PG_GETARG_TINYINT(1); 1201 | int64 result; 1202 | 1203 | if (arg2 == 0) 1204 | ereport(ERROR, 1205 | (errcode(ERRCODE_DIVISION_BY_ZERO), 1206 | errmsg("division by zero"))); 1207 | 1208 | result = arg1 / arg2; 1209 | 1210 | /* no overflow possible? */ 1211 | PG_RETURN_INT64(result); 1212 | } 1213 | 1214 | Datum 1215 | tinyint_mod(PG_FUNCTION_ARGS) 1216 | { 1217 | tinyint arg1 = PG_GETARG_TINYINT(0); 1218 | tinyint arg2 = PG_GETARG_TINYINT(1); 1219 | 1220 | if (arg2 == 0) 1221 | ereport(ERROR, 1222 | (errcode(ERRCODE_DIVISION_BY_ZERO), 1223 | errmsg("division by zero"))); 1224 | /* No overflow is possible */ 1225 | PG_RETURN_TINYINT(arg1 % arg2); 1226 | } 1227 | 1228 | Datum 1229 | tinyint_abs(PG_FUNCTION_ARGS) 1230 | { 1231 | tinyint arg1 = PG_GETARG_TINYINT(0); 1232 | tinyint result; 1233 | 1234 | result = (arg1 < 0) ? -arg1 : arg1; 1235 | /* overflow check (needed for SCHAR_MIN) */ 1236 | if (result < 0) 1237 | ereport(ERROR, 1238 | (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), 1239 | errmsg("tinyint out of range"))); 1240 | PG_RETURN_TINYINT(result); 1241 | } 1242 | 1243 | Datum 1244 | tinyint_larger(PG_FUNCTION_ARGS) 1245 | { 1246 | tinyint arg1 = PG_GETARG_TINYINT(0); 1247 | tinyint arg2 = PG_GETARG_TINYINT(1); 1248 | 1249 | PG_RETURN_TINYINT((arg1 > arg2) ? arg1 : arg2); 1250 | } 1251 | 1252 | Datum 1253 | tinyint_smaller(PG_FUNCTION_ARGS) 1254 | { 1255 | tinyint arg1 = PG_GETARG_TINYINT(0); 1256 | tinyint arg2 = PG_GETARG_TINYINT(1); 1257 | 1258 | PG_RETURN_TINYINT((arg1 < arg2) ? arg1 : arg2); 1259 | } 1260 | 1261 | Datum 1262 | tinyint_and(PG_FUNCTION_ARGS) 1263 | { 1264 | tinyint arg1 = PG_GETARG_TINYINT(0); 1265 | tinyint arg2 = PG_GETARG_TINYINT(1); 1266 | 1267 | PG_RETURN_TINYINT(arg1 & arg2); 1268 | } 1269 | 1270 | Datum 1271 | tinyint_or(PG_FUNCTION_ARGS) 1272 | { 1273 | tinyint arg1 = PG_GETARG_TINYINT(0); 1274 | tinyint arg2 = PG_GETARG_TINYINT(1); 1275 | 1276 | PG_RETURN_TINYINT(arg1 | arg2); 1277 | } 1278 | 1279 | Datum 1280 | tinyint_xor(PG_FUNCTION_ARGS) 1281 | { 1282 | tinyint arg1 = PG_GETARG_TINYINT(0); 1283 | tinyint arg2 = PG_GETARG_TINYINT(1); 1284 | 1285 | PG_RETURN_TINYINT(arg1 ^ arg2); 1286 | } 1287 | 1288 | Datum 1289 | tinyint_shl(PG_FUNCTION_ARGS) 1290 | { 1291 | tinyint arg1 = PG_GETARG_TINYINT(0); 1292 | tinyint arg2 = PG_GETARG_TINYINT(1); 1293 | 1294 | PG_RETURN_TINYINT(arg1 << arg2); 1295 | } 1296 | 1297 | Datum 1298 | tinyint_shr(PG_FUNCTION_ARGS) 1299 | { 1300 | tinyint arg1 = PG_GETARG_TINYINT(0); 1301 | tinyint arg2 = PG_GETARG_TINYINT(1); 1302 | 1303 | PG_RETURN_TINYINT(arg1 >> arg2); 1304 | } 1305 | 1306 | Datum 1307 | tinyint_not(PG_FUNCTION_ARGS) 1308 | { 1309 | tinyint arg1 = PG_GETARG_TINYINT(0); 1310 | 1311 | PG_RETURN_TINYINT(~arg1); 1312 | } 1313 | 1314 | /* 1315 | * ======================== 1316 | * BTREE STRATEGY OPERATORS 1317 | * ======================== 1318 | */ 1319 | 1320 | Datum 1321 | bt_tinyint_cmp(PG_FUNCTION_ARGS) 1322 | { 1323 | tinyint a = PG_GETARG_TINYINT(0); 1324 | tinyint b = PG_GETARG_TINYINT(1); 1325 | 1326 | PG_RETURN_INT32((int32) a - (int32) b); 1327 | } 1328 | 1329 | Datum 1330 | bt_tinyint_i2_cmp(PG_FUNCTION_ARGS) 1331 | { 1332 | tinyint a = PG_GETARG_TINYINT(0); 1333 | int16 b = PG_GETARG_INT16(1); 1334 | 1335 | PG_RETURN_INT32((int32) a - (int32) b); 1336 | } 1337 | 1338 | Datum 1339 | bt_tinyint_i4_cmp(PG_FUNCTION_ARGS) 1340 | { 1341 | tinyint a = PG_GETARG_TINYINT(0); 1342 | int32 b = PG_GETARG_INT32(1); 1343 | 1344 | PG_RETURN_INT32((int32) a - (int32) b); 1345 | } 1346 | 1347 | Datum 1348 | bt_tinyint_i8_cmp(PG_FUNCTION_ARGS) 1349 | { 1350 | tinyint a = PG_GETARG_TINYINT(0); 1351 | int64 b = PG_GETARG_INT64(1); 1352 | 1353 | if (a > b) 1354 | PG_RETURN_INT32(1); 1355 | else if (a == b) 1356 | PG_RETURN_INT32(0); 1357 | else 1358 | PG_RETURN_INT32(-1); 1359 | } 1360 | 1361 | Datum 1362 | bt_i2_tinyint_cmp(PG_FUNCTION_ARGS) 1363 | { 1364 | int16 a = PG_GETARG_INT16(0); 1365 | tinyint b = PG_GETARG_TINYINT(1); 1366 | 1367 | PG_RETURN_INT32((int32) a - (int32) b); 1368 | } 1369 | 1370 | Datum 1371 | bt_i4_tinyint_cmp(PG_FUNCTION_ARGS) 1372 | { 1373 | int32 a = PG_GETARG_INT32(0); 1374 | tinyint b = PG_GETARG_TINYINT(1); 1375 | 1376 | PG_RETURN_INT32((int32) a - (int32) b); 1377 | } 1378 | 1379 | Datum 1380 | bt_i8_tinyint_cmp(PG_FUNCTION_ARGS) 1381 | { 1382 | int64 a = PG_GETARG_INT64(0); 1383 | tinyint b = PG_GETARG_TINYINT(1); 1384 | 1385 | if (a > b) 1386 | PG_RETURN_INT32(1); 1387 | else if (a == b) 1388 | PG_RETURN_INT32(0); 1389 | else 1390 | PG_RETURN_INT32(-1); 1391 | } 1392 | 1393 | Datum 1394 | hash_tinyint(PG_FUNCTION_ARGS) 1395 | { 1396 | return hash_uint32((int32) PG_GETARG_TINYINT(0)); 1397 | } 1398 | 1399 | Datum 1400 | tinyint_sum(PG_FUNCTION_ARGS) 1401 | { 1402 | int64 newval; 1403 | 1404 | if (PG_ARGISNULL(0)) 1405 | { 1406 | /* No non-null input seen so far... */ 1407 | if (PG_ARGISNULL(1)) 1408 | PG_RETURN_NULL(); /* still no non-null */ 1409 | /* This is the first non-null input. */ 1410 | newval = (int64) PG_GETARG_TINYINT(1); 1411 | PG_RETURN_INT64(newval); 1412 | } 1413 | 1414 | /* 1415 | * If we're invoked by nodeAgg, we can cheat and modify our first 1416 | * parameter in-place to avoid palloc overhead. If not, we need to return 1417 | * the new value of the transition variable. 1418 | * (If int8 is pass-by-value, then of course this is useless as well 1419 | * as incorrect, so just ifdef it out.) 1420 | */ 1421 | #ifndef USE_FLOAT8_BYVAL /* controls int8 too */ 1422 | if (fcinfo->context && 1423 | #if PG_VERSION_NUM >= 80400 1424 | (IsA(fcinfo->context, AggState) || 1425 | IsA(fcinfo->context, WindowAggState))) 1426 | #else 1427 | (IsA(fcinfo->context, AggState))) 1428 | #endif 1429 | { 1430 | int64 *oldsum = (int64 *) PG_GETARG_POINTER(0); 1431 | 1432 | /* Leave the running sum unchanged in the new input is null */ 1433 | if (!PG_ARGISNULL(1)) 1434 | *oldsum = *oldsum + (int64) PG_GETARG_TINYINT(1); 1435 | 1436 | PG_RETURN_POINTER(oldsum); 1437 | } 1438 | else 1439 | #endif 1440 | { 1441 | int64 oldsum = PG_GETARG_INT64(0); 1442 | 1443 | /* Leave sum unchanged if new input is null. */ 1444 | if (PG_ARGISNULL(1)) 1445 | PG_RETURN_INT64(oldsum); 1446 | 1447 | /* OK to do the addition. */ 1448 | newval = oldsum + (int64) PG_GETARG_TINYINT(1); 1449 | 1450 | PG_RETURN_INT64(newval); 1451 | } 1452 | } 1453 | 1454 | /* 1455 | * Routines for avg(int2) and avg(int4). The transition datatype 1456 | * is a two-element int8 array, holding count and sum. 1457 | */ 1458 | 1459 | typedef struct Int8TransTypeData 1460 | { 1461 | #ifndef INT64_IS_BUSTED 1462 | int64 count; 1463 | int64 sum; 1464 | #else 1465 | /* "int64" isn't really 64 bits, so fake up properly-aligned fields */ 1466 | int32 count; 1467 | int32 pad1; 1468 | int32 sum; 1469 | int32 pad2; 1470 | #endif 1471 | } Int8TransTypeData; 1472 | 1473 | Datum 1474 | tinyint_avg_accum(PG_FUNCTION_ARGS) 1475 | { 1476 | ArrayType *transarray; 1477 | tinyint newval = PG_GETARG_TINYINT(1); 1478 | Int8TransTypeData *transdata; 1479 | 1480 | /* 1481 | * If we're invoked by nodeAgg, we can cheat and modify our first 1482 | * parameter in-place to reduce palloc overhead. Otherwise we need to make 1483 | * a copy of it before scribbling on it. 1484 | */ 1485 | if (fcinfo->context && 1486 | #if PG_VERSION_NUM >= 80400 1487 | (IsA(fcinfo->context, AggState) || 1488 | IsA(fcinfo->context, WindowAggState))) 1489 | #else 1490 | (IsA(fcinfo->context, AggState))) 1491 | #endif 1492 | transarray = PG_GETARG_ARRAYTYPE_P(0); 1493 | else 1494 | transarray = PG_GETARG_ARRAYTYPE_P_COPY(0); 1495 | 1496 | if (ARR_HASNULL(transarray) || 1497 | ARR_SIZE(transarray) != ARR_OVERHEAD_NONULLS(1) + sizeof(Int8TransTypeData)) 1498 | elog(ERROR, "expected 2-element int8 array"); 1499 | 1500 | transdata = (Int8TransTypeData *) ARR_DATA_PTR(transarray); 1501 | transdata->count++; 1502 | transdata->sum += newval; 1503 | 1504 | PG_RETURN_ARRAYTYPE_P(transarray); 1505 | } 1506 | 1507 | -------------------------------------------------------------------------------- /tinyint.control: -------------------------------------------------------------------------------- 1 | # tinyint extension 2 | comment = '1 byte integer data type' 3 | default_version = '0.1.1' 4 | module_pathname = '$libdir/tinyint' 5 | relocatable = true 6 | -------------------------------------------------------------------------------- /tinyint.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef TINYINT_H 3 | #define TINYINT_H 4 | 5 | #include 6 | 7 | #include "fmgr.h" 8 | 9 | 10 | typedef char tinyint; 11 | 12 | #define DatumGetTinyInt(X) ((tinyint) GET_1_BYTE(X)) 13 | #define TinyIntGetDatum(X) ((Datum) SET_1_BYTE(X)) 14 | 15 | #define PG_GETARG_TINYINT(n) DatumGetTinyInt(PG_GETARG_DATUM(n)) 16 | #define PG_RETURN_TINYINT(x) return TinyIntGetDatum(x) 17 | 18 | extern Datum tinyint_in(PG_FUNCTION_ARGS); 19 | extern Datum tinyint_out(PG_FUNCTION_ARGS); 20 | extern Datum tinyint_recv(PG_FUNCTION_ARGS); 21 | extern Datum tinyint_send(PG_FUNCTION_ARGS); 22 | 23 | extern Datum tinyint_to_i2(PG_FUNCTION_ARGS); 24 | extern Datum i2_to_tinyint(PG_FUNCTION_ARGS); 25 | extern Datum tinyint_to_i4(PG_FUNCTION_ARGS); 26 | extern Datum i4_to_tinyint(PG_FUNCTION_ARGS); 27 | extern Datum tinyint_to_i8(PG_FUNCTION_ARGS); 28 | extern Datum i8_to_tinyint(PG_FUNCTION_ARGS); 29 | extern Datum tinyint_to_bool(PG_FUNCTION_ARGS); 30 | extern Datum bool_to_tinyint(PG_FUNCTION_ARGS); 31 | 32 | extern Datum tinyint_eq(PG_FUNCTION_ARGS); 33 | extern Datum tinyint_ne(PG_FUNCTION_ARGS); 34 | extern Datum tinyint_lt(PG_FUNCTION_ARGS); 35 | extern Datum tinyint_le(PG_FUNCTION_ARGS); 36 | extern Datum tinyint_gt(PG_FUNCTION_ARGS); 37 | extern Datum tinyint_ge(PG_FUNCTION_ARGS); 38 | 39 | extern Datum tinyint_i2_eq(PG_FUNCTION_ARGS); 40 | extern Datum tinyint_i2_ne(PG_FUNCTION_ARGS); 41 | extern Datum tinyint_i2_lt(PG_FUNCTION_ARGS); 42 | extern Datum tinyint_i2_le(PG_FUNCTION_ARGS); 43 | extern Datum tinyint_i2_gt(PG_FUNCTION_ARGS); 44 | extern Datum tinyint_i2_ge(PG_FUNCTION_ARGS); 45 | 46 | extern Datum tinyint_i4_eq(PG_FUNCTION_ARGS); 47 | extern Datum tinyint_i4_ne(PG_FUNCTION_ARGS); 48 | extern Datum tinyint_i4_lt(PG_FUNCTION_ARGS); 49 | extern Datum tinyint_i4_le(PG_FUNCTION_ARGS); 50 | extern Datum tinyint_i4_gt(PG_FUNCTION_ARGS); 51 | extern Datum tinyint_i4_ge(PG_FUNCTION_ARGS); 52 | 53 | extern Datum tinyint_i8_eq(PG_FUNCTION_ARGS); 54 | extern Datum tinyint_i8_ne(PG_FUNCTION_ARGS); 55 | extern Datum tinyint_i8_lt(PG_FUNCTION_ARGS); 56 | extern Datum tinyint_i8_le(PG_FUNCTION_ARGS); 57 | extern Datum tinyint_i8_gt(PG_FUNCTION_ARGS); 58 | extern Datum tinyint_i8_ge(PG_FUNCTION_ARGS); 59 | 60 | extern Datum i2_tinyint_eq(PG_FUNCTION_ARGS); 61 | extern Datum i2_tinyint_ne(PG_FUNCTION_ARGS); 62 | extern Datum i2_tinyint_lt(PG_FUNCTION_ARGS); 63 | extern Datum i2_tinyint_le(PG_FUNCTION_ARGS); 64 | extern Datum i2_tinyint_gt(PG_FUNCTION_ARGS); 65 | extern Datum i2_tinyint_ge(PG_FUNCTION_ARGS); 66 | 67 | extern Datum i4_tinyint_eq(PG_FUNCTION_ARGS); 68 | extern Datum i4_tinyint_ne(PG_FUNCTION_ARGS); 69 | extern Datum i4_tinyint_lt(PG_FUNCTION_ARGS); 70 | extern Datum i4_tinyint_le(PG_FUNCTION_ARGS); 71 | extern Datum i4_tinyint_gt(PG_FUNCTION_ARGS); 72 | extern Datum i4_tinyint_ge(PG_FUNCTION_ARGS); 73 | 74 | extern Datum i8_tinyint_eq(PG_FUNCTION_ARGS); 75 | extern Datum i8_tinyint_ne(PG_FUNCTION_ARGS); 76 | extern Datum i8_tinyint_lt(PG_FUNCTION_ARGS); 77 | extern Datum i8_tinyint_le(PG_FUNCTION_ARGS); 78 | extern Datum i8_tinyint_gt(PG_FUNCTION_ARGS); 79 | extern Datum i8_tinyint_ge(PG_FUNCTION_ARGS); 80 | 81 | extern Datum tinyint_um(PG_FUNCTION_ARGS); 82 | extern Datum tinyint_up(PG_FUNCTION_ARGS); 83 | extern Datum tinyint_pl(PG_FUNCTION_ARGS); 84 | extern Datum tinyint_mi(PG_FUNCTION_ARGS); 85 | extern Datum tinyint_mul(PG_FUNCTION_ARGS); 86 | extern Datum tinyint_div(PG_FUNCTION_ARGS); 87 | extern Datum tinyint_inc(PG_FUNCTION_ARGS); 88 | 89 | extern Datum tinyint_i2_pl(PG_FUNCTION_ARGS); 90 | extern Datum tinyint_i2_mi(PG_FUNCTION_ARGS); 91 | extern Datum tinyint_i2_mul(PG_FUNCTION_ARGS); 92 | extern Datum tinyint_i2_div(PG_FUNCTION_ARGS); 93 | 94 | extern Datum tinyint_i4_pl(PG_FUNCTION_ARGS); 95 | extern Datum tinyint_i4_mi(PG_FUNCTION_ARGS); 96 | extern Datum tinyint_i4_mul(PG_FUNCTION_ARGS); 97 | extern Datum tinyint_i4_div(PG_FUNCTION_ARGS); 98 | 99 | extern Datum tinyint_i8_pl(PG_FUNCTION_ARGS); 100 | extern Datum tinyint_i8_mi(PG_FUNCTION_ARGS); 101 | extern Datum tinyint_i8_mul(PG_FUNCTION_ARGS); 102 | extern Datum tinyint_i8_div(PG_FUNCTION_ARGS); 103 | 104 | extern Datum i2_tinyint_pl(PG_FUNCTION_ARGS); 105 | extern Datum i2_tinyint_mi(PG_FUNCTION_ARGS); 106 | extern Datum i2_tinyint_mul(PG_FUNCTION_ARGS); 107 | extern Datum i2_tinyint_div(PG_FUNCTION_ARGS); 108 | 109 | extern Datum i4_tinyint_pl(PG_FUNCTION_ARGS); 110 | extern Datum i4_tinyint_mi(PG_FUNCTION_ARGS); 111 | extern Datum i4_tinyint_mul(PG_FUNCTION_ARGS); 112 | extern Datum i4_tinyint_div(PG_FUNCTION_ARGS); 113 | 114 | extern Datum i8_tinyint_pl(PG_FUNCTION_ARGS); 115 | extern Datum i8_tinyint_mi(PG_FUNCTION_ARGS); 116 | extern Datum i8_tinyint_mul(PG_FUNCTION_ARGS); 117 | extern Datum i8_tinyint_div(PG_FUNCTION_ARGS); 118 | 119 | extern Datum tinyint_mod(PG_FUNCTION_ARGS); 120 | extern Datum tinyint_abs(PG_FUNCTION_ARGS); 121 | extern Datum tinyint_larger(PG_FUNCTION_ARGS); 122 | extern Datum tinyint_smaller(PG_FUNCTION_ARGS); 123 | extern Datum tinyint_and(PG_FUNCTION_ARGS); 124 | extern Datum tinyint_or(PG_FUNCTION_ARGS); 125 | extern Datum tinyint_xor(PG_FUNCTION_ARGS); 126 | extern Datum tinyint_shl(PG_FUNCTION_ARGS); 127 | extern Datum tinyint_shr(PG_FUNCTION_ARGS); 128 | extern Datum tinyint_not(PG_FUNCTION_ARGS); 129 | 130 | extern Datum bt_tinyint_cmp(PG_FUNCTION_ARGS); 131 | extern Datum bt_tinyint_i2_cmp(PG_FUNCTION_ARGS); 132 | extern Datum bt_tinyint_i4_cmp(PG_FUNCTION_ARGS); 133 | extern Datum bt_tinyint_i8_cmp(PG_FUNCTION_ARGS); 134 | extern Datum bt_i2_tinyint_cmp(PG_FUNCTION_ARGS); 135 | extern Datum bt_i4_tinyint_cmp(PG_FUNCTION_ARGS); 136 | extern Datum bt_i8_tinyint_cmp(PG_FUNCTION_ARGS); 137 | 138 | extern Datum hash_tinyint(PG_FUNCTION_ARGS); 139 | 140 | extern Datum tinyint_sum(PG_FUNCTION_ARGS); 141 | extern Datum tinyint_avg_accum(PG_FUNCTION_ARGS); 142 | 143 | #endif /* TINYINT_H */ 144 | -------------------------------------------------------------------------------- /tinyint.sql.in.c: -------------------------------------------------------------------------------- 1 | #include "pg_config.h" 2 | 3 | CREATE FUNCTION tinyint_in(cstring) RETURNS tinyint AS 4 | 'MODULE_PATHNAME' 5 | LANGUAGE c IMMUTABLE STRICT; 6 | CREATE FUNCTION tinyint_out(tinyint) RETURNS cstring AS 7 | 'MODULE_PATHNAME' 8 | LANGUAGE c IMMUTABLE STRICT; 9 | CREATE FUNCTION tinyint_recv(internal) RETURNS tinyint AS 10 | 'MODULE_PATHNAME' 11 | LANGUAGE c IMMUTABLE STRICT; 12 | CREATE FUNCTION tinyint_send(tinyint) RETURNS bytea AS 13 | 'MODULE_PATHNAME' 14 | LANGUAGE c IMMUTABLE STRICT; 15 | 16 | CREATE TYPE tinyint ( 17 | INPUT = tinyint_in, 18 | OUTPUT = tinyint_out, 19 | RECEIVE = tinyint_recv, 20 | SEND = tinyint_send, 21 | INTERNALLENGTH = 1, 22 | PASSEDBYVALUE, 23 | ALIGNMENT = char, 24 | STORAGE = plain 25 | ); 26 | 27 | CREATE FUNCTION tinyint_to_i2(tinyint) RETURNS smallint AS 28 | 'MODULE_PATHNAME' 29 | LANGUAGE c IMMUTABLE STRICT; 30 | CREATE CAST (tinyint AS smallint) 31 | WITH FUNCTION tinyint_to_i2(tinyint) AS IMPLICIT; 32 | 33 | CREATE FUNCTION i2_to_tinyint(smallint) RETURNS tinyint AS 34 | 'MODULE_PATHNAME' 35 | LANGUAGE c IMMUTABLE STRICT; 36 | CREATE CAST (smallint AS tinyint) 37 | WITH FUNCTION i2_to_tinyint(smallint) AS ASSIGNMENT; 38 | 39 | CREATE FUNCTION tinyint_to_i4(tinyint) RETURNS integer AS 40 | 'MODULE_PATHNAME' 41 | LANGUAGE c IMMUTABLE STRICT; 42 | CREATE CAST (tinyint AS integer) 43 | WITH FUNCTION tinyint_to_i4(tinyint) AS IMPLICIT; 44 | 45 | CREATE FUNCTION i4_to_tinyint(integer) RETURNS tinyint AS 46 | 'MODULE_PATHNAME' 47 | LANGUAGE c IMMUTABLE STRICT; 48 | CREATE CAST (integer AS tinyint) 49 | WITH FUNCTION i4_to_tinyint(integer) AS ASSIGNMENT; 50 | 51 | CREATE FUNCTION tinyint_to_i8(tinyint) RETURNS bigint AS 52 | 'MODULE_PATHNAME' 53 | LANGUAGE c IMMUTABLE STRICT; 54 | CREATE CAST (tinyint AS bigint) 55 | WITH FUNCTION tinyint_to_i8(tinyint) AS IMPLICIT; 56 | 57 | CREATE FUNCTION i8_to_tinyint(bigint) RETURNS tinyint AS 58 | 'MODULE_PATHNAME' 59 | LANGUAGE c IMMUTABLE STRICT; 60 | CREATE CAST (bigint AS tinyint) 61 | WITH FUNCTION i8_to_tinyint(bigint) AS ASSIGNMENT; 62 | 63 | CREATE FUNCTION tinyint_to_bool(tinyint) RETURNS bool AS 64 | 'MODULE_PATHNAME' 65 | LANGUAGE c IMMUTABLE STRICT; 66 | CREATE CAST (tinyint AS bool) 67 | WITH FUNCTION tinyint_to_bool(tinyint) AS ASSIGNMENT; 68 | 69 | CREATE FUNCTION bool_to_tinyint(bool) RETURNS tinyint AS 70 | 'MODULE_PATHNAME' 71 | LANGUAGE c IMMUTABLE STRICT; 72 | CREATE CAST (bool AS tinyint) 73 | WITH FUNCTION bool_to_tinyint(bool) AS ASSIGNMENT; 74 | 75 | CREATE FUNCTION tinyint_lt(tinyint, tinyint) RETURNS bool AS 76 | 'MODULE_PATHNAME' 77 | LANGUAGE c IMMUTABLE STRICT; 78 | CREATE OPERATOR < ( 79 | LEFTARG = tinyint, 80 | RIGHTARG = tinyint, 81 | PROCEDURE = tinyint_lt, 82 | COMMUTATOR = >, 83 | NEGATOR = >=, 84 | RESTRICT = scalarltsel, 85 | JOIN = scalarltjoinsel 86 | ); 87 | 88 | CREATE FUNCTION tinyint_le(tinyint, tinyint) RETURNS bool AS 89 | 'MODULE_PATHNAME' 90 | LANGUAGE c IMMUTABLE STRICT; 91 | CREATE OPERATOR <= ( 92 | LEFTARG = tinyint, 93 | RIGHTARG = tinyint, 94 | PROCEDURE = tinyint_le, 95 | COMMUTATOR = >=, 96 | NEGATOR = >, 97 | RESTRICT = scalarltsel, 98 | JOIN = scalarltjoinsel 99 | ); 100 | 101 | CREATE FUNCTION tinyint_gt(tinyint, tinyint) RETURNS bool AS 102 | 'MODULE_PATHNAME' 103 | LANGUAGE c IMMUTABLE STRICT; 104 | CREATE OPERATOR > ( 105 | LEFTARG = tinyint, 106 | RIGHTARG = tinyint, 107 | PROCEDURE = tinyint_gt, 108 | COMMUTATOR = <, 109 | NEGATOR = <=, 110 | RESTRICT = scalargtsel, 111 | JOIN = scalargtjoinsel 112 | ); 113 | 114 | CREATE FUNCTION tinyint_ge(tinyint, tinyint) RETURNS bool AS 115 | 'MODULE_PATHNAME' 116 | LANGUAGE c IMMUTABLE STRICT; 117 | CREATE OPERATOR >= ( 118 | LEFTARG = tinyint, 119 | RIGHTARG = tinyint, 120 | PROCEDURE = tinyint_ge, 121 | COMMUTATOR = <=, 122 | NEGATOR = <, 123 | RESTRICT = scalargtsel, 124 | JOIN = scalargtjoinsel 125 | ); 126 | 127 | CREATE FUNCTION tinyint_eq(tinyint, tinyint) RETURNS bool AS 128 | 'MODULE_PATHNAME' 129 | LANGUAGE c IMMUTABLE STRICT; 130 | CREATE OPERATOR = ( 131 | LEFTARG = tinyint, 132 | RIGHTARG = tinyint, 133 | PROCEDURE = tinyint_eq, 134 | COMMUTATOR = =, 135 | NEGATOR = <>, 136 | RESTRICT = eqsel, 137 | JOIN = eqjoinsel, 138 | HASHES, 139 | MERGES 140 | ); 141 | 142 | CREATE FUNCTION tinyint_ne(tinyint, tinyint) RETURNS bool AS 143 | 'MODULE_PATHNAME' 144 | LANGUAGE c IMMUTABLE STRICT; 145 | CREATE OPERATOR <> ( 146 | LEFTARG = tinyint, 147 | RIGHTARG = tinyint, 148 | PROCEDURE = tinyint_ne, 149 | COMMUTATOR = <>, 150 | NEGATOR = =, 151 | RESTRICT = neqsel, 152 | JOIN = neqjoinsel, 153 | MERGES 154 | ); 155 | 156 | 157 | CREATE FUNCTION tinyint_i2_eq(tinyint, smallint) RETURNS bool AS 158 | 'MODULE_PATHNAME' 159 | LANGUAGE c IMMUTABLE STRICT; 160 | CREATE OPERATOR = ( 161 | LEFTARG = tinyint, 162 | RIGHTARG = smallint, 163 | PROCEDURE = tinyint_i2_eq, 164 | COMMUTATOR = =, 165 | NEGATOR = <>, 166 | RESTRICT = eqsel, 167 | JOIN = eqjoinsel, 168 | HASHES, 169 | MERGES 170 | ); 171 | 172 | CREATE FUNCTION tinyint_i2_ne(tinyint, smallint) RETURNS bool AS 173 | 'MODULE_PATHNAME' 174 | LANGUAGE c IMMUTABLE STRICT; 175 | CREATE OPERATOR <> ( 176 | LEFTARG = tinyint, 177 | RIGHTARG = smallint, 178 | PROCEDURE = tinyint_i2_ne, 179 | COMMUTATOR = <>, 180 | NEGATOR = =, 181 | RESTRICT = neqsel, 182 | JOIN = neqjoinsel, 183 | MERGES 184 | ); 185 | 186 | CREATE FUNCTION tinyint_i2_lt(tinyint, smallint) RETURNS bool AS 187 | 'MODULE_PATHNAME' 188 | LANGUAGE c IMMUTABLE STRICT; 189 | CREATE OPERATOR < ( 190 | LEFTARG = tinyint, 191 | RIGHTARG = smallint, 192 | PROCEDURE = tinyint_i2_lt, 193 | COMMUTATOR = >, 194 | NEGATOR = >=, 195 | RESTRICT = scalarltsel, 196 | JOIN = scalarltjoinsel 197 | ); 198 | 199 | CREATE FUNCTION tinyint_i2_le(tinyint, smallint) RETURNS bool AS 200 | 'MODULE_PATHNAME' 201 | LANGUAGE c IMMUTABLE STRICT; 202 | CREATE OPERATOR <= ( 203 | LEFTARG = tinyint, 204 | RIGHTARG = smallint, 205 | PROCEDURE = tinyint_i2_le, 206 | COMMUTATOR = >=, 207 | NEGATOR = >, 208 | RESTRICT = scalarltsel, 209 | JOIN = scalarltjoinsel 210 | ); 211 | 212 | CREATE FUNCTION tinyint_i2_gt(tinyint, smallint) RETURNS bool AS 213 | 'MODULE_PATHNAME' 214 | LANGUAGE c IMMUTABLE STRICT; 215 | CREATE OPERATOR > ( 216 | LEFTARG = tinyint, 217 | RIGHTARG = smallint, 218 | PROCEDURE = tinyint_i2_gt, 219 | COMMUTATOR = <, 220 | NEGATOR = <=, 221 | RESTRICT = scalargtsel, 222 | JOIN = scalargtjoinsel 223 | ); 224 | 225 | CREATE FUNCTION tinyint_i2_ge(tinyint, smallint) RETURNS bool AS 226 | 'MODULE_PATHNAME' 227 | LANGUAGE c IMMUTABLE STRICT; 228 | CREATE OPERATOR >= ( 229 | LEFTARG = tinyint, 230 | RIGHTARG = smallint, 231 | PROCEDURE = tinyint_i2_ge, 232 | COMMUTATOR = <=, 233 | NEGATOR = <, 234 | RESTRICT = scalargtsel, 235 | JOIN = scalargtjoinsel 236 | ); 237 | 238 | 239 | CREATE FUNCTION tinyint_i4_eq(tinyint, integer) RETURNS bool AS 240 | 'MODULE_PATHNAME' 241 | LANGUAGE c IMMUTABLE STRICT; 242 | CREATE OPERATOR = ( 243 | LEFTARG = tinyint, 244 | RIGHTARG = integer, 245 | PROCEDURE = tinyint_i4_eq, 246 | COMMUTATOR = =, 247 | NEGATOR = <>, 248 | RESTRICT = eqsel, 249 | JOIN = eqjoinsel, 250 | HASHES, 251 | MERGES 252 | ); 253 | 254 | CREATE FUNCTION tinyint_i4_ne(tinyint, integer) RETURNS bool AS 255 | 'MODULE_PATHNAME' 256 | LANGUAGE c IMMUTABLE STRICT; 257 | CREATE OPERATOR <> ( 258 | LEFTARG = tinyint, 259 | RIGHTARG = integer, 260 | PROCEDURE = tinyint_i4_ne, 261 | COMMUTATOR = <>, 262 | NEGATOR = =, 263 | RESTRICT = neqsel, 264 | JOIN = neqjoinsel, 265 | MERGES 266 | ); 267 | 268 | CREATE FUNCTION tinyint_i4_lt(tinyint, integer) RETURNS bool AS 269 | 'MODULE_PATHNAME' 270 | LANGUAGE c IMMUTABLE STRICT; 271 | CREATE OPERATOR < ( 272 | LEFTARG = tinyint, 273 | RIGHTARG = integer, 274 | PROCEDURE = tinyint_i4_lt, 275 | COMMUTATOR = >, 276 | NEGATOR = >=, 277 | RESTRICT = scalarltsel, 278 | JOIN = scalarltjoinsel 279 | ); 280 | 281 | CREATE FUNCTION tinyint_i4_le(tinyint, integer) RETURNS bool AS 282 | 'MODULE_PATHNAME' 283 | LANGUAGE c IMMUTABLE STRICT; 284 | CREATE OPERATOR <= ( 285 | LEFTARG = tinyint, 286 | RIGHTARG = integer, 287 | PROCEDURE = tinyint_i4_le, 288 | COMMUTATOR = >=, 289 | NEGATOR = >, 290 | RESTRICT = scalarltsel, 291 | JOIN = scalarltjoinsel 292 | ); 293 | 294 | CREATE FUNCTION tinyint_i4_gt(tinyint, integer) RETURNS bool AS 295 | 'MODULE_PATHNAME' 296 | LANGUAGE c IMMUTABLE STRICT; 297 | CREATE OPERATOR > ( 298 | LEFTARG = tinyint, 299 | RIGHTARG = integer, 300 | PROCEDURE = tinyint_i4_gt, 301 | COMMUTATOR = <, 302 | NEGATOR = <=, 303 | RESTRICT = scalargtsel, 304 | JOIN = scalargtjoinsel 305 | ); 306 | 307 | CREATE FUNCTION tinyint_i4_ge(tinyint, integer) RETURNS bool AS 308 | 'MODULE_PATHNAME' 309 | LANGUAGE c IMMUTABLE STRICT; 310 | CREATE OPERATOR >= ( 311 | LEFTARG = tinyint, 312 | RIGHTARG = integer, 313 | PROCEDURE = tinyint_i4_ge, 314 | COMMUTATOR = <, 315 | NEGATOR = <=, 316 | RESTRICT = scalargtsel, 317 | JOIN = scalargtjoinsel 318 | ); 319 | 320 | 321 | CREATE FUNCTION tinyint_i8_eq(tinyint, bigint) RETURNS bool AS 322 | 'MODULE_PATHNAME' 323 | LANGUAGE c IMMUTABLE STRICT; 324 | CREATE OPERATOR = ( 325 | LEFTARG = tinyint, 326 | RIGHTARG = bigint, 327 | PROCEDURE = tinyint_i8_eq, 328 | COMMUTATOR = =, 329 | NEGATOR = <>, 330 | RESTRICT = eqsel, 331 | JOIN = eqjoinsel, 332 | HASHES, 333 | MERGES 334 | ); 335 | 336 | CREATE FUNCTION tinyint_i8_ne(tinyint, bigint) RETURNS bool AS 337 | 'MODULE_PATHNAME' 338 | LANGUAGE c IMMUTABLE STRICT; 339 | CREATE OPERATOR <> ( 340 | LEFTARG = tinyint, 341 | RIGHTARG = bigint, 342 | PROCEDURE = tinyint_i8_ne, 343 | COMMUTATOR = <>, 344 | NEGATOR = =, 345 | RESTRICT = neqsel, 346 | JOIN = neqjoinsel, 347 | MERGES 348 | ); 349 | 350 | CREATE FUNCTION tinyint_i8_lt(tinyint, bigint) RETURNS bool AS 351 | 'MODULE_PATHNAME' 352 | LANGUAGE c IMMUTABLE STRICT; 353 | CREATE OPERATOR < ( 354 | LEFTARG = tinyint, 355 | RIGHTARG = bigint, 356 | PROCEDURE = tinyint_i8_lt, 357 | COMMUTATOR = >, 358 | NEGATOR = >=, 359 | RESTRICT = scalarltsel, 360 | JOIN = scalarltjoinsel 361 | ); 362 | 363 | CREATE FUNCTION tinyint_i8_le(tinyint, bigint) RETURNS bool AS 364 | 'MODULE_PATHNAME' 365 | LANGUAGE c IMMUTABLE STRICT; 366 | CREATE OPERATOR <= ( 367 | LEFTARG = tinyint, 368 | RIGHTARG = bigint, 369 | PROCEDURE = tinyint_i8_le, 370 | COMMUTATOR = >=, 371 | NEGATOR = >, 372 | RESTRICT = scalarltsel, 373 | JOIN = scalarltjoinsel 374 | ); 375 | 376 | CREATE FUNCTION tinyint_i8_gt(tinyint, bigint) RETURNS bool AS 377 | 'MODULE_PATHNAME' 378 | LANGUAGE c IMMUTABLE STRICT; 379 | CREATE OPERATOR > ( 380 | LEFTARG = tinyint, 381 | RIGHTARG = bigint, 382 | PROCEDURE = tinyint_i8_gt, 383 | COMMUTATOR = <, 384 | NEGATOR = <=, 385 | RESTRICT = scalargtsel, 386 | JOIN = scalargtjoinsel 387 | ); 388 | 389 | CREATE FUNCTION tinyint_i8_ge(tinyint, bigint) RETURNS bool AS 390 | 'MODULE_PATHNAME' 391 | LANGUAGE c IMMUTABLE STRICT; 392 | CREATE OPERATOR >= ( 393 | LEFTARG = tinyint, 394 | RIGHTARG = bigint, 395 | PROCEDURE = tinyint_i8_ge, 396 | COMMUTATOR = <, 397 | NEGATOR = <=, 398 | RESTRICT = scalargtsel, 399 | JOIN = scalargtjoinsel 400 | ); 401 | 402 | 403 | CREATE FUNCTION i2_tinyint_eq(smallint, tinyint) RETURNS bool AS 404 | 'MODULE_PATHNAME' 405 | LANGUAGE c IMMUTABLE STRICT; 406 | CREATE OPERATOR = ( 407 | LEFTARG = smallint, 408 | RIGHTARG = tinyint, 409 | PROCEDURE = i2_tinyint_eq, 410 | COMMUTATOR = =, 411 | NEGATOR = <>, 412 | RESTRICT = eqsel, 413 | JOIN = eqjoinsel, 414 | HASHES, 415 | MERGES 416 | ); 417 | 418 | CREATE FUNCTION i2_tinyint_ne(smallint, tinyint) RETURNS bool AS 419 | 'MODULE_PATHNAME' 420 | LANGUAGE c IMMUTABLE STRICT; 421 | CREATE OPERATOR <> ( 422 | LEFTARG = smallint, 423 | RIGHTARG = tinyint, 424 | PROCEDURE = i2_tinyint_ne, 425 | COMMUTATOR = <>, 426 | NEGATOR = =, 427 | RESTRICT = neqsel, 428 | JOIN = neqjoinsel, 429 | MERGES 430 | ); 431 | 432 | CREATE FUNCTION i2_tinyint_lt(smallint, tinyint) RETURNS bool AS 433 | 'MODULE_PATHNAME' 434 | LANGUAGE c IMMUTABLE STRICT; 435 | CREATE OPERATOR < ( 436 | LEFTARG = smallint, 437 | RIGHTARG = tinyint, 438 | PROCEDURE = i2_tinyint_lt, 439 | COMMUTATOR = >, 440 | NEGATOR = >=, 441 | RESTRICT = scalarltsel, 442 | JOIN = scalarltjoinsel 443 | ); 444 | 445 | CREATE FUNCTION i2_tinyint_le(smallint, tinyint) RETURNS bool AS 446 | 'MODULE_PATHNAME' 447 | LANGUAGE c IMMUTABLE STRICT; 448 | CREATE OPERATOR <= ( 449 | LEFTARG = smallint, 450 | RIGHTARG = tinyint, 451 | PROCEDURE = i2_tinyint_le, 452 | COMMUTATOR = >=, 453 | NEGATOR = >, 454 | RESTRICT = scalarltsel, 455 | JOIN = scalarltjoinsel 456 | ); 457 | 458 | CREATE FUNCTION i2_tinyint_gt(smallint, tinyint) RETURNS bool AS 459 | 'MODULE_PATHNAME' 460 | LANGUAGE c IMMUTABLE STRICT; 461 | CREATE OPERATOR > ( 462 | LEFTARG = smallint, 463 | RIGHTARG = tinyint, 464 | PROCEDURE = i2_tinyint_gt, 465 | COMMUTATOR = <, 466 | NEGATOR = <=, 467 | RESTRICT = scalargtsel, 468 | JOIN = scalargtjoinsel 469 | ); 470 | 471 | CREATE FUNCTION i2_tinyint_ge(smallint, tinyint) RETURNS bool AS 472 | 'MODULE_PATHNAME' 473 | LANGUAGE c IMMUTABLE STRICT; 474 | CREATE OPERATOR >= ( 475 | LEFTARG = smallint, 476 | RIGHTARG = tinyint, 477 | PROCEDURE = i2_tinyint_ge, 478 | COMMUTATOR = <, 479 | NEGATOR = <=, 480 | RESTRICT = scalargtsel, 481 | JOIN = scalargtjoinsel 482 | ); 483 | 484 | 485 | CREATE FUNCTION i4_tinyint_eq(integer, tinyint) RETURNS bool AS 486 | 'MODULE_PATHNAME' 487 | LANGUAGE c IMMUTABLE STRICT; 488 | CREATE OPERATOR = ( 489 | LEFTARG = integer, 490 | RIGHTARG = tinyint, 491 | PROCEDURE = i4_tinyint_eq, 492 | COMMUTATOR = =, 493 | NEGATOR = <>, 494 | RESTRICT = eqsel, 495 | JOIN = eqjoinsel, 496 | HASHES, 497 | MERGES 498 | ); 499 | 500 | CREATE FUNCTION i4_tinyint_ne(integer, tinyint) RETURNS bool AS 501 | 'MODULE_PATHNAME' 502 | LANGUAGE c IMMUTABLE STRICT; 503 | CREATE OPERATOR <> ( 504 | LEFTARG = integer, 505 | RIGHTARG = tinyint, 506 | PROCEDURE = i4_tinyint_ne, 507 | COMMUTATOR = <>, 508 | NEGATOR = =, 509 | RESTRICT = neqsel, 510 | JOIN = neqjoinsel, 511 | MERGES 512 | ); 513 | 514 | CREATE FUNCTION i4_tinyint_lt(integer, tinyint) RETURNS bool AS 515 | 'MODULE_PATHNAME' 516 | LANGUAGE c IMMUTABLE STRICT; 517 | CREATE OPERATOR < ( 518 | LEFTARG = integer, 519 | RIGHTARG = tinyint, 520 | PROCEDURE = i4_tinyint_lt, 521 | COMMUTATOR = >, 522 | NEGATOR = >=, 523 | RESTRICT = scalarltsel, 524 | JOIN = scalarltjoinsel 525 | ); 526 | 527 | CREATE FUNCTION i4_tinyint_le(integer, tinyint) RETURNS bool AS 528 | 'MODULE_PATHNAME' 529 | LANGUAGE c IMMUTABLE STRICT; 530 | CREATE OPERATOR <= ( 531 | LEFTARG = integer, 532 | RIGHTARG = tinyint, 533 | PROCEDURE = i4_tinyint_le, 534 | COMMUTATOR = >=, 535 | NEGATOR = >, 536 | RESTRICT = scalarltsel, 537 | JOIN = scalarltjoinsel 538 | ); 539 | 540 | CREATE FUNCTION i4_tinyint_gt(integer, tinyint) RETURNS bool AS 541 | 'MODULE_PATHNAME' 542 | LANGUAGE c IMMUTABLE STRICT; 543 | CREATE OPERATOR > ( 544 | LEFTARG = integer, 545 | RIGHTARG = tinyint, 546 | PROCEDURE = i4_tinyint_gt, 547 | COMMUTATOR = <, 548 | NEGATOR = <=, 549 | RESTRICT = scalargtsel, 550 | JOIN = scalargtjoinsel 551 | ); 552 | 553 | CREATE FUNCTION i4_tinyint_ge(integer, tinyint) RETURNS bool AS 554 | 'MODULE_PATHNAME' 555 | LANGUAGE c IMMUTABLE STRICT; 556 | CREATE OPERATOR >= ( 557 | LEFTARG = integer, 558 | RIGHTARG = tinyint, 559 | PROCEDURE = i4_tinyint_ge, 560 | COMMUTATOR = <, 561 | NEGATOR = <=, 562 | RESTRICT = scalargtsel, 563 | JOIN = scalargtjoinsel 564 | ); 565 | 566 | 567 | CREATE FUNCTION i8_tinyint_eq(bigint, tinyint) RETURNS bool AS 568 | 'MODULE_PATHNAME' 569 | LANGUAGE c IMMUTABLE STRICT; 570 | CREATE OPERATOR = ( 571 | LEFTARG = bigint, 572 | RIGHTARG = tinyint, 573 | PROCEDURE = i8_tinyint_eq, 574 | COMMUTATOR = =, 575 | NEGATOR = <>, 576 | RESTRICT = eqsel, 577 | JOIN = eqjoinsel, 578 | HASHES, 579 | MERGES 580 | ); 581 | 582 | CREATE FUNCTION i8_tinyint_ne(bigint, tinyint) RETURNS bool AS 583 | 'MODULE_PATHNAME' 584 | LANGUAGE c IMMUTABLE STRICT; 585 | CREATE OPERATOR <> ( 586 | LEFTARG = bigint, 587 | RIGHTARG = tinyint, 588 | PROCEDURE = i8_tinyint_ne, 589 | COMMUTATOR = <>, 590 | NEGATOR = =, 591 | RESTRICT = neqsel, 592 | JOIN = neqjoinsel, 593 | MERGES 594 | ); 595 | 596 | CREATE FUNCTION i8_tinyint_lt(bigint, tinyint) RETURNS bool AS 597 | 'MODULE_PATHNAME' 598 | LANGUAGE c IMMUTABLE STRICT; 599 | CREATE OPERATOR < ( 600 | LEFTARG = bigint, 601 | RIGHTARG = tinyint, 602 | PROCEDURE = i8_tinyint_lt, 603 | COMMUTATOR = >, 604 | NEGATOR = >=, 605 | RESTRICT = scalarltsel, 606 | JOIN = scalarltjoinsel 607 | ); 608 | 609 | CREATE FUNCTION i8_tinyint_le(bigint, tinyint) RETURNS bool AS 610 | 'MODULE_PATHNAME' 611 | LANGUAGE c IMMUTABLE STRICT; 612 | CREATE OPERATOR <= ( 613 | LEFTARG = bigint, 614 | RIGHTARG = tinyint, 615 | PROCEDURE = i8_tinyint_le, 616 | COMMUTATOR = >=, 617 | NEGATOR = >, 618 | RESTRICT = scalarltsel, 619 | JOIN = scalarltjoinsel 620 | ); 621 | 622 | CREATE FUNCTION i8_tinyint_gt(bigint, tinyint) RETURNS bool AS 623 | 'MODULE_PATHNAME' 624 | LANGUAGE c IMMUTABLE STRICT; 625 | CREATE OPERATOR > ( 626 | LEFTARG = bigint, 627 | RIGHTARG = tinyint, 628 | PROCEDURE = i8_tinyint_gt, 629 | COMMUTATOR = <, 630 | NEGATOR = <=, 631 | RESTRICT = scalargtsel, 632 | JOIN = scalargtjoinsel 633 | ); 634 | 635 | CREATE FUNCTION i8_tinyint_ge(bigint, tinyint) RETURNS bool AS 636 | 'MODULE_PATHNAME' 637 | LANGUAGE c IMMUTABLE STRICT; 638 | CREATE OPERATOR >= ( 639 | LEFTARG = bigint, 640 | RIGHTARG = tinyint, 641 | PROCEDURE = i8_tinyint_ge, 642 | COMMUTATOR = <, 643 | NEGATOR = <=, 644 | RESTRICT = scalargtsel, 645 | JOIN = scalargtjoinsel 646 | ); 647 | 648 | 649 | CREATE FUNCTION tinyint_um(tinyint) RETURNS tinyint AS 650 | 'MODULE_PATHNAME' 651 | LANGUAGE c IMMUTABLE STRICT; 652 | CREATE OPERATOR - ( 653 | RIGHTARG = tinyint, 654 | PROCEDURE = tinyint_um 655 | ); 656 | 657 | CREATE FUNCTION tinyint_up(tinyint) RETURNS tinyint AS 658 | 'MODULE_PATHNAME' 659 | LANGUAGE c IMMUTABLE STRICT; 660 | CREATE OPERATOR + ( 661 | RIGHTARG = tinyint, 662 | PROCEDURE = tinyint_up 663 | ); 664 | 665 | CREATE FUNCTION tinyint_pl(tinyint, tinyint) RETURNS tinyint AS 666 | 'MODULE_PATHNAME' 667 | LANGUAGE c IMMUTABLE STRICT; 668 | CREATE OPERATOR + ( 669 | LEFTARG = tinyint, 670 | RIGHTARG = tinyint, 671 | PROCEDURE = tinyint_pl, 672 | COMMUTATOR = + 673 | ); 674 | 675 | CREATE FUNCTION tinyint_mi(tinyint, tinyint) RETURNS tinyint AS 676 | 'MODULE_PATHNAME' 677 | LANGUAGE c IMMUTABLE STRICT; 678 | CREATE OPERATOR - ( 679 | LEFTARG = tinyint, 680 | RIGHTARG = tinyint, 681 | PROCEDURE = tinyint_mi 682 | ); 683 | 684 | CREATE FUNCTION tinyint_mul(tinyint, tinyint) RETURNS tinyint AS 685 | 'MODULE_PATHNAME' 686 | LANGUAGE c IMMUTABLE STRICT; 687 | CREATE OPERATOR * ( 688 | LEFTARG = tinyint, 689 | RIGHTARG = tinyint, 690 | PROCEDURE = tinyint_mul, 691 | COMMUTATOR = * 692 | ); 693 | 694 | CREATE FUNCTION tinyint_div(tinyint, tinyint) RETURNS tinyint AS 695 | 'MODULE_PATHNAME' 696 | LANGUAGE c IMMUTABLE STRICT; 697 | CREATE OPERATOR / ( 698 | LEFTARG = tinyint, 699 | RIGHTARG = tinyint, 700 | PROCEDURE = tinyint_div 701 | ); 702 | 703 | CREATE FUNCTION tinyint_inc(tinyint) RETURNS tinyint AS 704 | 'MODULE_PATHNAME' 705 | LANGUAGE c IMMUTABLE STRICT; 706 | 707 | CREATE FUNCTION tinyint_i2_pl(tinyint, smallint) RETURNS smallint AS 708 | 'MODULE_PATHNAME' 709 | LANGUAGE c IMMUTABLE STRICT; 710 | CREATE OPERATOR + ( 711 | LEFTARG = tinyint, 712 | RIGHTARG = smallint, 713 | PROCEDURE = tinyint_i2_pl, 714 | COMMUTATOR = + 715 | ); 716 | 717 | CREATE FUNCTION tinyint_i2_mi(tinyint, smallint) RETURNS smallint AS 718 | 'MODULE_PATHNAME' 719 | LANGUAGE c IMMUTABLE STRICT; 720 | CREATE OPERATOR - ( 721 | LEFTARG = tinyint, 722 | RIGHTARG = smallint, 723 | PROCEDURE = tinyint_i2_mi 724 | ); 725 | 726 | CREATE FUNCTION tinyint_i2_mul(tinyint, smallint) RETURNS smallint AS 727 | 'MODULE_PATHNAME' 728 | LANGUAGE c IMMUTABLE STRICT; 729 | CREATE OPERATOR * ( 730 | LEFTARG = tinyint, 731 | RIGHTARG = smallint, 732 | PROCEDURE = tinyint_i2_mul, 733 | COMMUTATOR = * 734 | ); 735 | 736 | CREATE FUNCTION tinyint_i2_div(tinyint, smallint) RETURNS smallint AS 737 | 'MODULE_PATHNAME' 738 | LANGUAGE c IMMUTABLE STRICT; 739 | CREATE OPERATOR / ( 740 | LEFTARG = tinyint, 741 | RIGHTARG = smallint, 742 | PROCEDURE = tinyint_i2_div 743 | ); 744 | 745 | 746 | CREATE FUNCTION tinyint_i4_pl(tinyint, integer) RETURNS integer AS 747 | 'MODULE_PATHNAME' 748 | LANGUAGE c IMMUTABLE STRICT; 749 | CREATE OPERATOR + ( 750 | LEFTARG = tinyint, 751 | RIGHTARG = integer, 752 | PROCEDURE = tinyint_i4_pl, 753 | COMMUTATOR = + 754 | ); 755 | 756 | CREATE FUNCTION tinyint_i4_mi(tinyint, integer) RETURNS integer AS 757 | 'MODULE_PATHNAME' 758 | LANGUAGE c IMMUTABLE STRICT; 759 | CREATE OPERATOR - ( 760 | LEFTARG = tinyint, 761 | RIGHTARG = integer, 762 | PROCEDURE = tinyint_i4_mi 763 | ); 764 | 765 | CREATE FUNCTION tinyint_i4_mul(tinyint, integer) RETURNS integer AS 766 | 'MODULE_PATHNAME' 767 | LANGUAGE c IMMUTABLE STRICT; 768 | CREATE OPERATOR * ( 769 | LEFTARG = tinyint, 770 | RIGHTARG = integer, 771 | PROCEDURE = tinyint_i4_mul, 772 | COMMUTATOR = * 773 | ); 774 | 775 | CREATE FUNCTION tinyint_i4_div(tinyint, integer) RETURNS integer AS 776 | 'MODULE_PATHNAME' 777 | LANGUAGE c IMMUTABLE STRICT; 778 | CREATE OPERATOR / ( 779 | LEFTARG = tinyint, 780 | RIGHTARG = integer, 781 | PROCEDURE = tinyint_i4_div 782 | ); 783 | 784 | 785 | CREATE FUNCTION tinyint_i8_pl(tinyint, bigint) RETURNS bigint AS 786 | 'MODULE_PATHNAME' 787 | LANGUAGE c IMMUTABLE STRICT; 788 | CREATE OPERATOR + ( 789 | LEFTARG = tinyint, 790 | RIGHTARG = bigint, 791 | PROCEDURE = tinyint_i8_pl, 792 | COMMUTATOR = + 793 | ); 794 | 795 | CREATE FUNCTION tinyint_i8_mi(tinyint, bigint) RETURNS bigint AS 796 | 'MODULE_PATHNAME' 797 | LANGUAGE c IMMUTABLE STRICT; 798 | CREATE OPERATOR - ( 799 | LEFTARG = tinyint, 800 | RIGHTARG = bigint, 801 | PROCEDURE = tinyint_i8_mi 802 | ); 803 | 804 | CREATE FUNCTION tinyint_i8_mul(tinyint, bigint) RETURNS bigint AS 805 | 'MODULE_PATHNAME' 806 | LANGUAGE c IMMUTABLE STRICT; 807 | CREATE OPERATOR * ( 808 | LEFTARG = tinyint, 809 | RIGHTARG = bigint, 810 | PROCEDURE = tinyint_i8_mul, 811 | COMMUTATOR = * 812 | ); 813 | 814 | CREATE FUNCTION tinyint_i8_div(tinyint, bigint) RETURNS bigint AS 815 | 'MODULE_PATHNAME' 816 | LANGUAGE c IMMUTABLE STRICT; 817 | CREATE OPERATOR / ( 818 | LEFTARG = tinyint, 819 | RIGHTARG = bigint, 820 | PROCEDURE = tinyint_i8_div 821 | ); 822 | 823 | 824 | CREATE FUNCTION i2_tinyint_pl(smallint, tinyint) RETURNS smallint AS 825 | 'MODULE_PATHNAME' 826 | LANGUAGE c IMMUTABLE STRICT; 827 | CREATE OPERATOR + ( 828 | LEFTARG = smallint, 829 | RIGHTARG = tinyint, 830 | PROCEDURE = i2_tinyint_pl, 831 | COMMUTATOR = + 832 | ); 833 | 834 | CREATE FUNCTION i2_tinyint_mi(smallint, tinyint) RETURNS smallint AS 835 | 'MODULE_PATHNAME' 836 | LANGUAGE c IMMUTABLE STRICT; 837 | CREATE OPERATOR - ( 838 | LEFTARG = smallint, 839 | RIGHTARG = tinyint, 840 | PROCEDURE = i2_tinyint_mi 841 | ); 842 | 843 | CREATE FUNCTION i2_tinyint_mul(smallint, tinyint) RETURNS smallint AS 844 | 'MODULE_PATHNAME' 845 | LANGUAGE c IMMUTABLE STRICT; 846 | CREATE OPERATOR * ( 847 | LEFTARG = smallint, 848 | RIGHTARG = tinyint, 849 | PROCEDURE = i2_tinyint_mul, 850 | COMMUTATOR = * 851 | ); 852 | 853 | CREATE FUNCTION i2_tinyint_div(smallint, tinyint) RETURNS smallint AS 854 | 'MODULE_PATHNAME' 855 | LANGUAGE c IMMUTABLE STRICT; 856 | CREATE OPERATOR / ( 857 | LEFTARG = smallint, 858 | RIGHTARG = tinyint, 859 | PROCEDURE = i2_tinyint_div 860 | ); 861 | 862 | 863 | CREATE FUNCTION i4_tinyint_pl(integer, tinyint) RETURNS integer AS 864 | 'MODULE_PATHNAME' 865 | LANGUAGE c IMMUTABLE STRICT; 866 | CREATE OPERATOR + ( 867 | LEFTARG = integer, 868 | RIGHTARG = tinyint, 869 | PROCEDURE = i4_tinyint_pl, 870 | COMMUTATOR = + 871 | ); 872 | 873 | CREATE FUNCTION i4_tinyint_mi(integer, tinyint) RETURNS integer AS 874 | 'MODULE_PATHNAME' 875 | LANGUAGE c IMMUTABLE STRICT; 876 | CREATE OPERATOR - ( 877 | LEFTARG = integer, 878 | RIGHTARG = tinyint, 879 | PROCEDURE = i4_tinyint_mi 880 | ); 881 | 882 | CREATE FUNCTION i4_tinyint_mul(integer, tinyint) RETURNS integer AS 883 | 'MODULE_PATHNAME' 884 | LANGUAGE c IMMUTABLE STRICT; 885 | CREATE OPERATOR * ( 886 | LEFTARG = integer, 887 | RIGHTARG = tinyint, 888 | PROCEDURE = i4_tinyint_mul, 889 | COMMUTATOR = * 890 | ); 891 | 892 | CREATE FUNCTION i4_tinyint_div(integer, tinyint) RETURNS integer AS 893 | 'MODULE_PATHNAME' 894 | LANGUAGE c IMMUTABLE STRICT; 895 | CREATE OPERATOR / ( 896 | LEFTARG = integer, 897 | RIGHTARG = tinyint, 898 | PROCEDURE = i4_tinyint_div 899 | ); 900 | 901 | 902 | CREATE FUNCTION i8_tinyint_pl(bigint, tinyint) RETURNS bigint AS 903 | 'MODULE_PATHNAME' 904 | LANGUAGE c IMMUTABLE STRICT; 905 | CREATE OPERATOR + ( 906 | LEFTARG = bigint, 907 | RIGHTARG = tinyint, 908 | PROCEDURE = i8_tinyint_pl, 909 | COMMUTATOR = + 910 | ); 911 | 912 | CREATE FUNCTION i8_tinyint_mi(bigint, tinyint) RETURNS bigint AS 913 | 'MODULE_PATHNAME' 914 | LANGUAGE c IMMUTABLE STRICT; 915 | CREATE OPERATOR - ( 916 | LEFTARG = bigint, 917 | RIGHTARG = tinyint, 918 | PROCEDURE = i8_tinyint_mi 919 | ); 920 | 921 | CREATE FUNCTION i8_tinyint_mul(bigint, tinyint) RETURNS bigint AS 922 | 'MODULE_PATHNAME' 923 | LANGUAGE c IMMUTABLE STRICT; 924 | CREATE OPERATOR * ( 925 | LEFTARG = bigint, 926 | RIGHTARG = tinyint, 927 | PROCEDURE = i8_tinyint_mul, 928 | COMMUTATOR = * 929 | ); 930 | 931 | CREATE FUNCTION i8_tinyint_div(bigint, tinyint) RETURNS bigint AS 932 | 'MODULE_PATHNAME' 933 | LANGUAGE c IMMUTABLE STRICT; 934 | CREATE OPERATOR / ( 935 | LEFTARG = bigint, 936 | RIGHTARG = tinyint, 937 | PROCEDURE = i8_tinyint_div 938 | ); 939 | 940 | 941 | CREATE FUNCTION tinyint_mod(tinyint, tinyint) RETURNS tinyint AS 942 | 'MODULE_PATHNAME' 943 | LANGUAGE c IMMUTABLE STRICT; 944 | CREATE OPERATOR % ( 945 | LEFTARG = tinyint, 946 | RIGHTARG = tinyint, 947 | PROCEDURE = tinyint_mod 948 | ); 949 | 950 | CREATE FUNCTION tinyint_abs(tinyint) RETURNS tinyint AS 951 | 'MODULE_PATHNAME' 952 | LANGUAGE c IMMUTABLE STRICT; 953 | CREATE FUNCTION tinyint_larger(tinyint, tinyint) RETURNS tinyint AS 954 | 'MODULE_PATHNAME' 955 | LANGUAGE c IMMUTABLE STRICT; 956 | CREATE AGGREGATE max(tinyint) ( 957 | SFUNC = tinyint_larger, 958 | STYPE = tinyint, 959 | SORTOP = > 960 | ); 961 | 962 | CREATE FUNCTION tinyint_smaller(tinyint, tinyint) RETURNS tinyint AS 963 | 'MODULE_PATHNAME' 964 | LANGUAGE c IMMUTABLE STRICT; 965 | CREATE AGGREGATE min(tinyint) ( 966 | SFUNC = tinyint_smaller, 967 | STYPE = tinyint, 968 | SORTOP = < 969 | ); 970 | 971 | CREATE FUNCTION tinyint_and(tinyint, tinyint) RETURNS tinyint AS 972 | 'MODULE_PATHNAME' 973 | LANGUAGE c IMMUTABLE STRICT; 974 | CREATE OPERATOR & ( 975 | LEFTARG = tinyint, 976 | RIGHTARG = tinyint, 977 | PROCEDURE = tinyint_and 978 | ); 979 | 980 | CREATE FUNCTION tinyint_or(tinyint, tinyint) RETURNS tinyint AS 981 | 'MODULE_PATHNAME' 982 | LANGUAGE c IMMUTABLE STRICT; 983 | CREATE OPERATOR | ( 984 | LEFTARG = tinyint, 985 | RIGHTARG = tinyint, 986 | PROCEDURE = tinyint_or 987 | ); 988 | CREATE FUNCTION tinyint_xor(tinyint, tinyint) RETURNS tinyint AS 989 | 'MODULE_PATHNAME' 990 | LANGUAGE c IMMUTABLE STRICT; 991 | CREATE OPERATOR # ( 992 | LEFTARG = tinyint, 993 | RIGHTARG = tinyint, 994 | PROCEDURE = tinyint_xor 995 | ); 996 | 997 | CREATE FUNCTION tinyint_shl(tinyint, tinyint) RETURNS tinyint AS 998 | 'MODULE_PATHNAME' 999 | LANGUAGE c IMMUTABLE STRICT; 1000 | CREATE OPERATOR << ( 1001 | LEFTARG = tinyint, 1002 | RIGHTARG = tinyint, 1003 | PROCEDURE = tinyint_shl 1004 | ); 1005 | 1006 | CREATE FUNCTION tinyint_shr(tinyint, tinyint) RETURNS tinyint AS 1007 | 'MODULE_PATHNAME' 1008 | LANGUAGE c IMMUTABLE STRICT; 1009 | CREATE OPERATOR >> ( 1010 | LEFTARG = tinyint, 1011 | RIGHTARG = tinyint, 1012 | PROCEDURE = tinyint_shr 1013 | ); 1014 | 1015 | CREATE FUNCTION tinyint_not(tinyint) RETURNS tinyint AS 1016 | 'MODULE_PATHNAME' 1017 | LANGUAGE c IMMUTABLE STRICT; 1018 | CREATE OPERATOR ~ ( 1019 | RIGHTARG = tinyint, 1020 | PROCEDURE = tinyint_not 1021 | ); 1022 | 1023 | CREATE FUNCTION bt_tinyint_cmp(tinyint, tinyint) RETURNS integer AS 1024 | 'MODULE_PATHNAME' 1025 | LANGUAGE c IMMUTABLE STRICT; 1026 | 1027 | CREATE FUNCTION bt_tinyint_i2_cmp(tinyint, smallint) RETURNS integer AS 1028 | 'MODULE_PATHNAME' 1029 | LANGUAGE c IMMUTABLE STRICT; 1030 | 1031 | CREATE FUNCTION bt_tinyint_i4_cmp(tinyint, integer) RETURNS integer AS 1032 | 'MODULE_PATHNAME' 1033 | LANGUAGE c IMMUTABLE STRICT; 1034 | 1035 | CREATE FUNCTION bt_tinyint_i8_cmp(tinyint, bigint) RETURNS integer AS 1036 | 'MODULE_PATHNAME' 1037 | LANGUAGE c IMMUTABLE STRICT; 1038 | 1039 | CREATE FUNCTION bt_i2_tinyint_cmp(smallint, tinyint) RETURNS integer AS 1040 | 'MODULE_PATHNAME' 1041 | LANGUAGE c IMMUTABLE STRICT; 1042 | 1043 | CREATE FUNCTION bt_i4_tinyint_cmp(integer, tinyint) RETURNS integer AS 1044 | 'MODULE_PATHNAME' 1045 | LANGUAGE c IMMUTABLE STRICT; 1046 | 1047 | CREATE FUNCTION bt_i8_tinyint_cmp(bigint, tinyint) RETURNS integer AS 1048 | 'MODULE_PATHNAME' 1049 | LANGUAGE c IMMUTABLE STRICT; 1050 | 1051 | CREATE OPERATOR CLASS btree_tinyint_ops 1052 | #if PG_VERSION_NUM >= 80300 1053 | DEFAULT FOR TYPE tinyint USING btree FAMILY integer_ops AS 1054 | #else 1055 | DEFAULT FOR TYPE tinyint USING btree AS 1056 | #endif 1057 | OPERATOR 1 <, 1058 | OPERATOR 2 <=, 1059 | OPERATOR 3 =, 1060 | OPERATOR 4 >=, 1061 | OPERATOR 5 >, 1062 | FUNCTION 1 bt_tinyint_cmp(tinyint, tinyint); 1063 | 1064 | #if PG_VERSION_NUM >= 80300 1065 | ALTER OPERATOR FAMILY integer_ops USING btree ADD 1066 | OPERATOR 1 < (tinyint, smallint), 1067 | OPERATOR 2 <= (tinyint, smallint), 1068 | OPERATOR 3 = (tinyint, smallint), 1069 | OPERATOR 4 >= (tinyint, smallint), 1070 | OPERATOR 5 > (tinyint, smallint), 1071 | FUNCTION 1 bt_tinyint_i2_cmp(tinyint, smallint), 1072 | 1073 | OPERATOR 1 < (tinyint, integer), 1074 | OPERATOR 2 <= (tinyint, integer), 1075 | OPERATOR 3 = (tinyint, integer), 1076 | OPERATOR 4 >= (tinyint, integer), 1077 | OPERATOR 5 > (tinyint, integer), 1078 | FUNCTION 1 bt_tinyint_i4_cmp(tinyint, integer), 1079 | 1080 | OPERATOR 1 < (tinyint, bigint), 1081 | OPERATOR 2 <= (tinyint, bigint), 1082 | OPERATOR 3 = (tinyint, bigint), 1083 | OPERATOR 4 >= (tinyint, bigint), 1084 | OPERATOR 5 > (tinyint, bigint), 1085 | FUNCTION 1 bt_tinyint_i8_cmp(tinyint, bigint), 1086 | 1087 | OPERATOR 1 < (smallint, tinyint), 1088 | OPERATOR 2 <= (smallint, tinyint), 1089 | OPERATOR 3 = (smallint, tinyint), 1090 | OPERATOR 4 >= (smallint, tinyint), 1091 | OPERATOR 5 > (smallint, tinyint), 1092 | FUNCTION 1 bt_i2_tinyint_cmp(smallint, tinyint), 1093 | 1094 | OPERATOR 1 < (integer, tinyint), 1095 | OPERATOR 2 <= (integer, tinyint), 1096 | OPERATOR 3 = (integer, tinyint), 1097 | OPERATOR 4 >= (integer, tinyint), 1098 | OPERATOR 5 > (integer, tinyint), 1099 | FUNCTION 1 bt_i4_tinyint_cmp(integer, tinyint), 1100 | 1101 | OPERATOR 1 < (bigint, tinyint), 1102 | OPERATOR 2 <= (bigint, tinyint), 1103 | OPERATOR 3 = (bigint, tinyint), 1104 | OPERATOR 4 >= (bigint, tinyint), 1105 | OPERATOR 5 > (bigint, tinyint), 1106 | FUNCTION 1 bt_i8_tinyint_cmp(bigint, tinyint) 1107 | ; 1108 | 1109 | #endif 1110 | 1111 | CREATE OPERATOR CLASS _tinyint_ops 1112 | DEFAULT FOR TYPE tinyint[] USING gin AS 1113 | OPERATOR 1 &&(anyarray, anyarray), 1114 | OPERATOR 2 @>(anyarray, anyarray), 1115 | #if PG_VERSION_NUM >= 80400 1116 | OPERATOR 3 <@(anyarray, anyarray), 1117 | OPERATOR 4 =(anyarray, anyarray), 1118 | #elif PG_VERSION_NUM >= 80300 1119 | OPERATOR 3 <@(anyarray, anyarray) RECHECK, 1120 | OPERATOR 4 =(anyarray, anyarray) RECHECK, 1121 | #endif 1122 | FUNCTION 1 bt_tinyint_cmp(tinyint, tinyint), 1123 | FUNCTION 2 ginarrayextract(anyarray, internal), 1124 | #if PG_VERSION_NUM >= 90100 1125 | FUNCTION 3 ginqueryarrayextract(anyarray, internal, smallint, internal, internal, internal, internal), 1126 | FUNCTION 4 ginarrayconsistent(internal, smallint, anyarray, integer, internal, internal, internal, internal), 1127 | #elif PG_VERSION_NUM >= 80400 1128 | FUNCTION 3 ginqueryarrayextract(anyarray, internal, smallint, internal, internal), 1129 | FUNCTION 4 ginarrayconsistent(internal, smallint, anyarray, integer, internal, internal), 1130 | #elif PG_VERSION_NUM >= 80300 1131 | FUNCTION 3 ginqueryarrayextract(anyarray, internal, smallint), 1132 | FUNCTION 4 ginarrayconsistent(internal, smallint, internal), 1133 | #elif PG_VERSION_NUM >= 80200 1134 | FUNCTION 3 ginarrayextract(anyarray, internal), 1135 | FUNCTION 4 ginarrayconsistent(internal, smallint, internal), 1136 | #endif 1137 | STORAGE tinyint; 1138 | 1139 | CREATE FUNCTION hash_tinyint(tinyint) RETURNS integer AS 1140 | 'MODULE_PATHNAME' 1141 | LANGUAGE c IMMUTABLE STRICT; 1142 | 1143 | CREATE OPERATOR CLASS hash_tinyint_ops 1144 | FOR TYPE tinyint USING hash FAMILY integer_ops AS 1145 | OPERATOR 1 =, 1146 | FUNCTION 1 hash_tinyint(tinyint); 1147 | 1148 | CREATE FUNCTION tinyint_sum(bigint, tinyint) RETURNS bigint AS 1149 | 'MODULE_PATHNAME' 1150 | LANGUAGE c IMMUTABLE; 1151 | CREATE AGGREGATE sum(tinyint) ( 1152 | SFUNC = tinyint_sum, 1153 | STYPE = bigint 1154 | ); 1155 | 1156 | CREATE FUNCTION tinyint_avg_accum(bigint[], tinyint) RETURNS bigint[] AS 1157 | 'MODULE_PATHNAME' 1158 | LANGUAGE c IMMUTABLE STRICT; 1159 | CREATE AGGREGATE avg(tinyint) ( 1160 | SFUNC = tinyint_avg_accum, 1161 | STYPE = bigint[], 1162 | INITCOND = '{0,0}', 1163 | FINALFUNC = int8_avg 1164 | ); 1165 | -------------------------------------------------------------------------------- /uninstall_tinyint.sql: -------------------------------------------------------------------------------- 1 | DROP TYPE tinyint CASCADE; 2 | --------------------------------------------------------------------------------