From f145dee6cc512666ca926512b72ed05185ce2389 Mon Sep 17 00:00:00 2001 From: Aaron Huber Date: Thu, 22 Feb 2024 15:02:46 -0500 Subject: [PATCH] Added pip_world_presence_join. --- ahuber_gitlab | 38 +++ ahuber_gitlab.pub | 1 + pip_plugin/Makefile | 6 +- pip_plugin/install.noctype.sql | 295 +++++++++++++++++++++ pip_plugin/pip-noctype.sql | 296 +++++++++++++++++++++ pip_plugin/pip-test.sql | 308 ++++++++++++++++++++++ pip_plugin/pip-test.sql.in | 308 ++++++++++++++++++++++ pip_plugin/pip-uninstall.sql | 132 ++++++++++ pip_plugin/pip-uninstall.sql.in | 132 ++++++++++ pip_plugin/pip.sql | 308 ++++++++++++++++++++++ pip_plugin/src/funcs.c | 1 + pip_plugin/src/funcs/pip_world_presence.c | 13 + pip_plugin/src/include/funcs.h | 2 + pip_plugin/src/pip.source | 1 + 14 files changed, 1838 insertions(+), 3 deletions(-) create mode 100644 ahuber_gitlab create mode 100644 ahuber_gitlab.pub create mode 100644 pip_plugin/install.noctype.sql create mode 100644 pip_plugin/pip-noctype.sql create mode 100644 pip_plugin/pip-test.sql create mode 100644 pip_plugin/pip-test.sql.in create mode 100644 pip_plugin/pip-uninstall.sql create mode 100644 pip_plugin/pip-uninstall.sql.in create mode 100644 pip_plugin/pip.sql diff --git a/ahuber_gitlab b/ahuber_gitlab new file mode 100644 index 0000000..38a8a28 --- /dev/null +++ b/ahuber_gitlab @@ -0,0 +1,38 @@ +-----BEGIN OPENSSH PRIVATE KEY----- +b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAABlwAAAAdzc2gtcn +NhAAAAAwEAAQAAAYEAzmWhv5JrejLEMhavehv15IUYBGNPVGwspRBNakvG62k6DnOuXgcI +eUJcGZQ5nRhH6osSnpDUJjgPNQWa6kaWQdqkbO2TnYeoqwtlX4LLP3Mjlt+P3VY3Lus9rq +4f5QIMQwaI9/L0MwSiuhm2/OHW53CBr/nqVx30Grc4W1F2DmW+/cn6z7Lzraepzu8Hfci9 +IuHpfkqK09pgMgYOj/EiZYT81uB+illG8a4CUOVMmaIGbMGZAKMziUstxJlwYiHrWm8dRv +JpQ4uIgJFAXAHDb8yxQ0JQAAlhHNC+bq5rXM88UsS0Syaof/VXu51AUgf/GCOeMW/wa0rl +PJkoP9LSrooKc5JeZIlaAhuzQpMWhq+uDnrimgm+Bp6Cl1qKO1Y5rK4joYEkQhUtFPHrrb +824LL87lDEz6QdgPnGrF1Z9YP34dhaosOc1rCBcDGwAH1+EXJxtv3C+ktPJy3kppi4ENNr +nOcGP5seNIx/DzQQ/4Blwq6mrRH5QRGhYz2qtBU7AAAFiAzQ8NcM0PDXAAAAB3NzaC1yc2 +EAAAGBAM5lob+Sa3oyxDIWr3ob9eSFGARjT1RsLKUQTWpLxutpOg5zrl4HCHlCXBmUOZ0Y +R+qLEp6Q1CY4DzUFmupGlkHapGztk52HqKsLZV+Cyz9zI5bfj91WNy7rPa6uH+UCDEMGiP +fy9DMEoroZtvzh1udwga/56lcd9Bq3OFtRdg5lvv3J+s+y862nqc7vB33IvSLh6X5KitPa +YDIGDo/xImWE/NbgfopZRvGuAlDlTJmiBmzBmQCjM4lLLcSZcGIh61pvHUbyaUOLiICRQF +wBw2/MsUNCUAAJYRzQvm6ua1zPPFLEtEsmqH/1V7udQFIH/xgjnjFv8GtK5TyZKD/S0q6K +CnOSXmSJWgIbs0KTFoavrg564poJvgaegpdaijtWOayuI6GBJEIVLRTx662/NuCy/O5QxM ++kHYD5xqxdWfWD9+HYWqLDnNawgXAxsAB9fhFycbb9wvpLTyct5KaYuBDTa5znBj+bHjSM +fw80EP+AZcKupq0R+UERoWM9qrQVOwAAAAMBAAEAAAGAIK8DYBzFnEIxw2TIQOPwmlFhLk +CzrUC8CR99wtlhFKJDKUq0T/t5IgqaHwrT3MadjMydFDMHBU5XSiQrFfI7lQ4Uf5NXjtiO +oxdY5DkICnInLpsUYw5mCq4BxImaT191pZ+BTRJSDUosop+z1HPG3jt4re87ZrQ9lYVyDT +PnJ/yAtBup9f32jIdCYpyDaS3ClaWEnhUbytSH6yP+ZljfA4h9qWE/aJUeoOLXRwwohyOb +NNmrauhtHs6i3sEVhNSt8TlH/3nZwv/+vgjYyqAUvLQBnvg43zKeGZZOfHAyCnJlrcbwA/ +RMxn1aVSpPpCMEXV4OthYyB7hzmWghZ8On6n5vAbNnw0eKnL6gYAP3TgZ/bvuSRJhA5svO +K29dnJId125SaDjjc1OAncNQec4JauJ8jCAMfdVQwzeSImAX7ZGHfjPUS8PEOD8jKpSZ6Q +UmAz5bHT+KROBAqTkRH97YDxu06ZdR0DWArO280DNPQacsnbPT7nFGg0lWRpv2+3WRAAAA +wQCHwE2eKgd606LgBv6+f5qoC/oanq5ZhhvcyE8ACjgflXm/sP0+uDECAxbfDanf7TJFFQ +epxhx2J7htnuQglvUa4hrzNsckffQjVmRNDLKjZXmtkN1C+uOgoHtncOlci7RpHAjEGbzm ++Dv9QwyJB+KpYfuASEzh1WuNUnfoJEvODj9zWiFnDb/FrehzawjBkhYTA1BR6SjiAsu/PT +nmVZpxjth3868JSTVV2tUHIM9/z4atLRUvewD5jGzcLYLYuKsAAADBAPuRtS5jG3CaMgyU +bJ1Uf0u/LlRACpL9TdoMSoD0vd3fHTUz+uKQtal/VVafLEzaM1aboaCxsXn2n7RNBTRHIt +b8Fg2viZI/gY6oCIrDF9+jPaVu8gc+czJFO+t29U7XcIeQpQXV8JR/F3Dx4v7RFofN8nqO +Mj9cSibnGcuUVBMIvUXiIrNtZY/3Wr8vttONfkJZsL7cFfCm+hBbPatddGyHtTTPfqpuUr +qnc1tCUP0kNMH1ngBDggq3aFjC2OER1wAAAMEA0gg/q/oVgvn6S1h4r2kma/cOVKSjFA8m +vj5CbVameXNy1TmN33nCniqa4GnBxHv6z+04Z8XKkC0qZs42rt47gY4ELpI7ICgNudKPXt +pSkmHNXtvbQayeR1TchV6lpmWQt30PipEclXy6SkLgi9cbJPJ5V6x0hXsekyU9xtRQMRXq +8In3BRePiVduxusR2jnHdWV2CfmHbxyGMMekV+7YiVCx4pXXna1wZJJdzFAXmsuIv5bnK3 +gnq5OPoBt3AzM9AAAADGFodWJlckB6b3J5YQECAwQFBg== +-----END OPENSSH PRIVATE KEY----- diff --git a/ahuber_gitlab.pub b/ahuber_gitlab.pub new file mode 100644 index 0000000..4f48106 --- /dev/null +++ b/ahuber_gitlab.pub @@ -0,0 +1 @@ +ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQDOZaG/kmt6MsQyFq96G/XkhRgEY09UbCylEE1qS8braToOc65eBwh5QlwZlDmdGEfqixKekNQmOA81BZrqRpZB2qRs7ZOdh6irC2Vfgss/cyOW34/dVjcu6z2urh/lAgxDBoj38vQzBKK6Gbb84dbncIGv+epXHfQatzhbUXYOZb79yfrPsvOtp6nO7wd9yL0i4el+SorT2mAyBg6P8SJlhPzW4H6KWUbxrgJQ5UyZogZswZkAozOJSy3EmXBiIetabx1G8mlDi4iAkUBcAcNvzLFDQlAACWEc0L5urmtczzxSxLRLJqh/9Ve7nUBSB/8YI54xb/BrSuU8mSg/0tKuigpzkl5kiVoCG7NCkxaGr64OeuKaCb4GnoKXWoo7VjmsriOhgSRCFS0U8eutvzbgsvzuUMTPpB2A+casXVn1g/fh2Fqiw5zWsIFwMbAAfX4RcnG2/cL6S08nLeSmmLgQ02uc5wY/mx40jH8PNBD/gGXCrqatEflBEaFjPaq0FTs= ahuber@zorya diff --git a/pip_plugin/Makefile b/pip_plugin/Makefile index 92a71e0..799a59b 100644 --- a/pip_plugin/Makefile +++ b/pip_plugin/Makefile @@ -12,7 +12,7 @@ LIBRARYCODE :=$(wildcard src/library/*.c) CORE :=src/pip.c src/list_utils.c GENERATED :=src/disttable.c src/funcs.c SCRIPTS := #src/dist/normal.dist -# INSTALL_DIR :=/maybms/install/ +#INSTALL_DIR :=/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip_install # because postgres likes to have the function info in the same # file as the functions themselves... we don't include the @@ -21,7 +21,7 @@ SCRIPTS := #src/dist/normal.dist SOURCEFILES=$(CORE) $(GENERATED) $(DISTRIBUTIONS) $(TYPES) $(SAMPLING) $(LIBRARYCODE) OBJS =$(subst .c,.o,$(SOURCEFILES)) -PG_CONFIG=pg_config +PG_CONFIG=/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/bin/pg_config MODULE_big:= pip DATA_built:= pip.sql pip-noctype.sql pip-uninstall.sql pip-test.sql # install.test.sql install.sql uninstall.sql $(SCRIPTS) @@ -42,7 +42,7 @@ src/disttable.c: $(DISTRIBUTIONS) scripts/gen_disttable.sh src/dist/normal.dist: scripts/normal.rb ./scripts/normal.rb > src/dist/normal.dist -pip.sql.in: src/pip.source +pip.sql: src/pip.source cat $< > $@ pip-noctype.sql: pip.sql diff --git a/pip_plugin/install.noctype.sql b/pip_plugin/install.noctype.sql new file mode 100644 index 0000000..a9a6ad1 --- /dev/null +++ b/pip_plugin/install.noctype.sql @@ -0,0 +1,295 @@ +CREATE SEQUENCE pip_var_id; + +--------------- VARIABLE PREDECLARATIONS --------------- +CREATE TYPE pip_var; +CREATE TYPE pip_atom; +CREATE TYPE pip_sample_set; +CREATE TYPE pip_conf_tally; +CREATE TYPE pip_value_bundle; +CREATE TYPE pip_world_presence; +CREATE TYPE pip_eqn; +CREATE TYPE pip_expectation; +CREATE TYPE pip_atomset; + +--------------- pip_var FUNCTIONS --------------- +CREATE FUNCTION pip_var_in(cstring) RETURNS pip_var AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_var_in' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_var_out(pip_var) RETURNS cstring AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_var_out' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION create_variable(cstring, integer, cstring) RETURNS pip_eqn AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_var_create_str' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION create_variable(cstring, integer, record) RETURNS pip_eqn AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_var_create_row' LANGUAGE C VOLATILE STRICT; + +--------------- pip_eqn FUNCTIONS --------------- +CREATE FUNCTION pip_eqn_in(cstring) RETURNS pip_eqn AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_eqn_in' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_out(pip_eqn) RETURNS cstring AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_eqn_out' LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION expectation(pip_eqn, record) RETURNS double precision AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_expectation' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION expectation(pip_eqn, record, integer) RETURNS double precision AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_expectation' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION expectation_max_g(pip_sample_set, pip_eqn, record) RETURNS pip_sample_set AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_expectation_max_g' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION expectation_max_g_one(pip_atomset, double precision, record) RETURNS pip_atomset AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_expectation_max_g_one' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION expectation_max_f_one(pip_atomset) RETURNS double precision AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_expectation_max_f_one' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION expectation_sum_g(pip_sample_set, pip_eqn, record) RETURNS pip_sample_set AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_expectation_sum_g' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION expectation_sum_g_one(double precision, pip_eqn, record) RETURNS double precision AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_expectation_sum_g_one' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION expectation_sum_g_one(double precision, pip_eqn, record, integer) RETURNS double precision AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_expectation_sum_g_one' LANGUAGE C VOLATILE STRICT; + +CREATE FUNCTION pip_eqn_sum(pip_eqn,pip_eqn) RETURNS pip_eqn AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_eqn_sum_ee' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_sum(pip_eqn,integer) RETURNS pip_eqn AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_eqn_sum_ei' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_sum(integer,pip_eqn) RETURNS pip_eqn AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_eqn_sum_ie' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_sum(pip_eqn,double precision) RETURNS pip_eqn AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_eqn_sum_ef' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_sum(double precision,pip_eqn) RETURNS pip_eqn AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_eqn_sum_fe' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_compile_sum(pip_eqn,pip_eqn,record) RETURNS pip_eqn AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_eqn_compile_sum' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_compile_sum(pip_eqn,pip_eqn ) RETURNS pip_eqn AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_eqn_compile_sum' LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION pip_eqn_mul(pip_eqn,pip_eqn) RETURNS pip_eqn AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_eqn_mul_ee' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_mul(pip_eqn,integer) RETURNS pip_eqn AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_eqn_mul_ei' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_mul(integer,pip_eqn) RETURNS pip_eqn AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_eqn_mul_ie' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_mul(pip_eqn,double precision) RETURNS pip_eqn AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_eqn_mul_ef' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_mul(double precision,pip_eqn) RETURNS pip_eqn AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_eqn_mul_fe' LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION pip_eqn_neg(pip_eqn) RETURNS pip_eqn AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_eqn_neg' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_sub(pip_eqn,pip_eqn) RETURNS pip_eqn AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_eqn_sub_ee' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_sub(pip_eqn,integer) RETURNS pip_eqn AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_eqn_sub_ei' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_sub(integer,pip_eqn) RETURNS pip_eqn AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_eqn_sub_ie' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_sub(pip_eqn,double precision) RETURNS pip_eqn AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_eqn_sub_ef' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_sub(double precision,pip_eqn) RETURNS pip_eqn AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_eqn_sub_fe' LANGUAGE C IMMUTABLE STRICT; + +--------------- pip_expectation FUNCTIONS --------------- +-- Expectation is a semantic sugar hack to cheat the parser... +-- Consequently the IO operations here are identical to those for pip_eqn +CREATE FUNCTION pip_expectation_in(cstring) RETURNS pip_expectation AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_exp_in' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_expectation_out(pip_expectation) RETURNS cstring AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_exp_out' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_expectation_make(pip_eqn) RETURNS pip_expectation AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_exp_make' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_expectation_fix(pip_expectation,record) RETURNS pip_expectation AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_exp_fix' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_expectation_expect(pip_expectation) RETURNS double precision AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_exp_expect' LANGUAGE C IMMUTABLE STRICT; + +--------------- pip_atom FUNCTIONS --------------- +CREATE FUNCTION pip_atom_in(cstring) RETURNS pip_atom AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_atom_in' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_atom_out(pip_atom) RETURNS cstring AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_atom_out' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_atom_create_gt(pip_eqn,pip_eqn) RETURNS pip_atom AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_atom_create_gt_ee' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION pip_atom_create_gt(pip_eqn,double precision) RETURNS pip_atom AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_atom_create_gt_ef' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION pip_atom_create_gt(double precision,pip_eqn) RETURNS pip_atom AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_atom_create_gt_fe' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION pip_atom_create_lt(pip_eqn,pip_eqn) RETURNS pip_atom AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_atom_create_lt_ee' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION pip_atom_create_lt(pip_eqn,double precision) RETURNS pip_atom AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_atom_create_lt_ef' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION pip_atom_create_lt(double precision,pip_eqn) RETURNS pip_atom AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_atom_create_lt_fe' LANGUAGE C VOLATILE STRICT; + +--------------- pip_atomset FUNCTIONS --------------- +CREATE FUNCTION pip_atomset_in(cstring) RETURNS pip_atomset AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_atomset_in' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_atomset_out(pip_atomset) RETURNS cstring AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_atomset_out' LANGUAGE C IMMUTABLE STRICT; + +--------------- pip_sample_set FUNCTIONS --------------- +CREATE FUNCTION pip_sample_set_in(cstring) RETURNS pip_sample_set AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_sample_set_in' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_sample_set_out(pip_sample_set) RETURNS cstring AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_sample_set_out' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_sample_set_generate(record,integer) RETURNS pip_sample_set AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_sample_set_generate' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION pip_sample_set_explode(pip_sample_set) RETURNS SETOF double precision AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_sample_set_explode' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_sample_set_expect(pip_sample_set) RETURNS double precision AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_sample_set_expect' LANGUAGE C IMMUTABLE STRICT; + +--------------- INTEGRATION FUNCTIONS --------------- +CREATE FUNCTION conf_one (record) RETURNS double precision AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','conf_one' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION conf_sample_g (pip_conf_tally,record,pip_sample_set) RETURNS pip_conf_tally AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_atom_conf_sample_g' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION conf_naive_g (pip_world_presence,record,pip_sample_set) RETURNS pip_world_presence AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_atom_sample_set_presence' LANGUAGE C IMMUTABLE STRICT; + +--------------- pip_conf_tally FUNCTIONS --------------- +CREATE FUNCTION pip_conf_tally_in(cstring) RETURNS pip_conf_tally AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_conf_tally_in' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_conf_tally_out(pip_conf_tally) RETURNS cstring AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_conf_tally_out' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_conf_tally_result(pip_conf_tally) RETURNS double precision AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_conf_tally_result' LANGUAGE C IMMUTABLE STRICT; + +--------------- pip_world_presence FUNCTIONS --------------- +CREATE FUNCTION pip_world_presence_in(cstring) RETURNS pip_world_presence AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_world_presence_in' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_world_presence_out(pip_world_presence) RETURNS cstring AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_world_presence_out' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_world_presence_create(integer) RETURNS pip_world_presence AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_world_presence_create' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION pip_world_presence_count(pip_world_presence) RETURNS double precision AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_world_presence_count' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_world_presence_union(pip_world_presence,pip_world_presence) RETURNS pip_world_presence AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_world_presence_union' LANGUAGE C IMMUTABLE STRICT; + +--------------- pip_value_bundle FUNCTIONS --------------- +CREATE FUNCTION pip_value_bundle_in(cstring) RETURNS pip_value_bundle AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_value_bundle_in' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_out(pip_value_bundle) RETURNS cstring AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_value_bundle_out' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_create(pip_eqn,integer) RETURNS pip_value_bundle AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_value_bundle_create' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION pip_value_bundle_cmp(pip_world_presence,integer,pip_value_bundle) RETURNS pip_world_presence AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_value_bundle_cmp_iv' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_cmp(pip_world_presence,double precision,pip_value_bundle) RETURNS pip_world_presence AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_value_bundle_cmp_fv' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_cmp(pip_world_presence,pip_value_bundle,integer) RETURNS pip_world_presence AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_value_bundle_cmp_vi' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_cmp(pip_world_presence,pip_value_bundle,double precision) RETURNS pip_world_presence AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_value_bundle_cmp_vf' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_cmp(pip_world_presence,pip_value_bundle,pip_value_bundle) RETURNS pip_world_presence AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_value_bundle_cmp_vv' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_add(pip_value_bundle,double precision) RETURNS pip_value_bundle AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_value_bundle_add_vf' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_add(pip_value_bundle,pip_value_bundle) RETURNS pip_value_bundle AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_value_bundle_add_vv' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_add(pip_value_bundle,pip_value_bundle,pip_world_presence) RETURNS pip_value_bundle AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_value_bundle_add_vv' LANGUAGE C IMMUTABLE; +CREATE FUNCTION pip_value_bundle_mul(pip_value_bundle,double precision) RETURNS pip_value_bundle AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_value_bundle_mul_vf' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_mul(pip_value_bundle,pip_value_bundle) RETURNS pip_value_bundle AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_value_bundle_mul_vv' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_max(pip_value_bundle,pip_value_bundle) RETURNS pip_value_bundle AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_value_bundle_max' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_expect(pip_value_bundle) RETURNS double precision AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_value_bundle_expect' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_expect(pip_value_bundle,pip_world_presence) RETURNS double precision AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_value_bundle_expect' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_expect(pip_value_bundle,integer,integer) RETURNS double precision AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_value_bundle_expect' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_expect(pip_value_bundle,integer,integer,pip_world_presence) RETURNS double precision AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_value_bundle_expect' LANGUAGE C IMMUTABLE STRICT; + +--------------- DEBUG/TEST FUNCTIONS --------------- +CREATE FUNCTION pip_cdf_enabled(integer) RETURNS integer AS '/home/csgrad/ahuber/db_systems/postgresql-8.4.22/postgresql-8.4.22-install/MayBMS_Mirror/pip_plugin/pip.so','pip_set_cdf_sampling_enabled' LANGUAGE C IMMUTABLE STRICT; + +--------------- VARIABLE DEFINITIONS --------------- +CREATE TYPE pip_var ( + INPUT = pip_var_in, + OUTPUT = pip_var_out, + STORAGE = external +); +CREATE TYPE pip_atom ( + INPUT = pip_atom_in, + OUTPUT = pip_atom_out, + STORAGE = external +); +CREATE TYPE pip_sample_set ( + INPUT = pip_sample_set_in, + OUTPUT = pip_sample_set_out, + STORAGE = external +); +CREATE TYPE pip_conf_tally ( + INPUT = pip_conf_tally_in, + OUTPUT = pip_conf_tally_out, + STORAGE = external +); +CREATE TYPE pip_value_bundle ( + INPUT = pip_value_bundle_in, + OUTPUT = pip_value_bundle_out, + STORAGE = external +); +CREATE TYPE pip_world_presence ( + INPUT = pip_world_presence_in, + OUTPUT = pip_world_presence_out, + STORAGE = external +); +CREATE TYPE pip_eqn ( + INPUT = pip_eqn_in, + OUTPUT = pip_eqn_out, + STORAGE = external +); +CREATE TYPE pip_expectation ( + INPUT = pip_expectation_in, + OUTPUT = pip_expectation_out, + STORAGE = external +); +CREATE TYPE pip_atomset ( + INPUT = pip_atomset_in, + OUTPUT = pip_atomset_out, + STORAGE = external +); + +--------------- AGGREGATE FUNCTIONS --------------- +CREATE AGGREGATE expectation_max (pip_eqn, record) +( + sfunc = expectation_max_g, + stype = pip_sample_set, + finalfunc = pip_sample_set_expect, + initcond = '?1000/1' +); +CREATE AGGREGATE expectation_max_hist (pip_eqn, record) +( + sfunc = expectation_max_g, + stype = pip_sample_set, + initcond = '?1000/1' +); + +CREATE AGGREGATE expectation_sum (pip_eqn, record, integer) +( + sfunc = expectation_sum_g_one, + stype = double precision, + initcond = '0.0' +); +CREATE AGGREGATE expectation_sum (pip_eqn, record) +( + sfunc = expectation_sum_g_one, + stype = double precision, + initcond = '0.0' +); +CREATE AGGREGATE expectation_sum_hist (pip_eqn, record) +( + sfunc = expectation_sum_g, + stype = pip_sample_set, + initcond = '?1000/1' +); + +CREATE AGGREGATE conf_sample (record,pip_sample_set) +( + sfunc = conf_sample_g, + stype = pip_conf_tally, + finalfunc = pip_conf_tally_result, + initcond = '0:0' +); + +CREATE AGGREGATE pip_world_presence_union (pip_world_presence) +( + sfunc = pip_world_presence_union, + stype = pip_world_presence +); + +CREATE AGGREGATE conf_naive (record,pip_sample_set) +( + sfunc = conf_naive_g, + stype = pip_world_presence, + finalfunc = pip_world_presence_count, + initcond = '?0' +); +CREATE AGGREGATE sum (pip_value_bundle) +( + sfunc = pip_value_bundle_add, + stype = pip_value_bundle +); +CREATE AGGREGATE sum (pip_value_bundle,pip_world_presence) +( + sfunc = pip_value_bundle_add, + stype = pip_value_bundle +); +CREATE AGGREGATE expectation_max (pip_value_bundle) +( + sfunc = pip_value_bundle_max, + stype = pip_value_bundle, + finalfunc = pip_value_bundle_expect +); +CREATE AGGREGATE max(double precision, record) +( + sfunc = expectation_max_g_one, + stype = pip_atomset, + finalfunc = expectation_max_f_one, + initcond = '?8' +-- sortop = > +); +CREATE AGGREGATE sum(pip_eqn) +( + --We label this as a constraint type, since it can be applied on + --constrained columns... the corresponding constraints are pulled into the eqn. + sfunc = pip_eqn_compile_sum, + stype = pip_eqn, + initcond = '(0)' +); + +--------------- FUNCTIONS IN SQL --------------- +CREATE FUNCTION create_variable(varchar, anyelement) RETURNS pip_eqn AS $$ + SELECT create_variable(cast($1 as cstring), cast(nextval('pip_var_id') as integer), $2); + $$ LANGUAGE SQL VOLATILE STRICT; + +--------------- VARIABLE OPERATORS --------------- +CREATE OPERATOR + ( PROCEDURE=pip_eqn_sum, LEFTARG=pip_eqn , RIGHTARG=pip_eqn ); +CREATE OPERATOR + ( PROCEDURE=pip_eqn_sum, LEFTARG=integer , RIGHTARG=pip_eqn ); +CREATE OPERATOR + ( PROCEDURE=pip_eqn_sum, LEFTARG=pip_eqn , RIGHTARG=integer ); +CREATE OPERATOR + ( PROCEDURE=pip_eqn_sum, LEFTARG=double precision, RIGHTARG=pip_eqn ); +CREATE OPERATOR + ( PROCEDURE=pip_eqn_sum, LEFTARG=pip_eqn , RIGHTARG=double precision ); + +CREATE OPERATOR * ( PROCEDURE=pip_eqn_mul, LEFTARG=pip_eqn , RIGHTARG=pip_eqn ); +CREATE OPERATOR * ( PROCEDURE=pip_eqn_mul, LEFTARG=integer , RIGHTARG=pip_eqn ); +CREATE OPERATOR * ( PROCEDURE=pip_eqn_mul, LEFTARG=pip_eqn , RIGHTARG=integer ); +CREATE OPERATOR * ( PROCEDURE=pip_eqn_mul, LEFTARG=double precision, RIGHTARG=pip_eqn ); +CREATE OPERATOR * ( PROCEDURE=pip_eqn_mul, LEFTARG=pip_eqn , RIGHTARG=double precision ); + +CREATE OPERATOR - ( PROCEDURE=pip_eqn_sub, LEFTARG=pip_eqn , RIGHTARG=pip_eqn ); +CREATE OPERATOR - ( PROCEDURE=pip_eqn_sub, LEFTARG=integer , RIGHTARG=pip_eqn ); +CREATE OPERATOR - ( PROCEDURE=pip_eqn_sub, LEFTARG=pip_eqn , RIGHTARG=integer ); +CREATE OPERATOR - ( PROCEDURE=pip_eqn_sub, LEFTARG=double precision, RIGHTARG=pip_eqn ); +CREATE OPERATOR - ( PROCEDURE=pip_eqn_sub, LEFTARG=pip_eqn , RIGHTARG=double precision ); + +CREATE OPERATOR | ( PROCEDURE=pip_world_presence_union, LEFTARG=pip_world_presence, RIGHTARG=pip_world_presence ); + +CREATE OPERATOR > ( PROCEDURE=pip_atom_create_gt, LEFTARG=pip_eqn, RIGHTARG=pip_eqn ); +CREATE OPERATOR > ( PROCEDURE=pip_atom_create_gt, LEFTARG=double precision, RIGHTARG=pip_eqn ); +CREATE OPERATOR > ( PROCEDURE=pip_atom_create_gt, LEFTARG=pip_eqn, RIGHTARG=double precision ); +CREATE OPERATOR < ( PROCEDURE=pip_atom_create_lt, LEFTARG=pip_eqn, RIGHTARG=pip_eqn ); +CREATE OPERATOR < ( PROCEDURE=pip_atom_create_lt, LEFTARG=pip_eqn, RIGHTARG=double precision ); +CREATE OPERATOR < ( PROCEDURE=pip_atom_create_lt, LEFTARG=double precision, RIGHTARG=pip_eqn ); + +--------------- SEMANTIC SUGAR OPERATORS --------------- +CREATE OPERATOR << ( PROCEDURE=pip_expectation_make, RIGHTARG=pip_eqn ); +CREATE OPERATOR @ ( PROCEDURE=pip_expectation_fix, LEFTARG=pip_expectation, RIGHTARG=record ); +CREATE OPERATOR >> ( PROCEDURE=pip_expectation_expect, LEFTARG=pip_expectation ); diff --git a/pip_plugin/pip-noctype.sql b/pip_plugin/pip-noctype.sql new file mode 100644 index 0000000..76f5383 --- /dev/null +++ b/pip_plugin/pip-noctype.sql @@ -0,0 +1,296 @@ +CREATE SEQUENCE pip_var_id; + +--------------- VARIABLE PREDECLARATIONS --------------- +CREATE TYPE pip_var; +CREATE TYPE pip_atom; +CREATE TYPE pip_sample_set; +CREATE TYPE pip_conf_tally; +CREATE TYPE pip_value_bundle; +CREATE TYPE pip_world_presence; +CREATE TYPE pip_eqn; +CREATE TYPE pip_expectation; +CREATE TYPE pip_atomset; + +--------------- pip_var FUNCTIONS --------------- +CREATE FUNCTION pip_var_in(cstring) RETURNS pip_var AS 'MODULE_PATHNAME','pip_var_in' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_var_out(pip_var) RETURNS cstring AS 'MODULE_PATHNAME','pip_var_out' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION create_variable(cstring, integer, cstring) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_var_create_str' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION create_variable(cstring, integer, record) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_var_create_row' LANGUAGE C VOLATILE STRICT; + +--------------- pip_eqn FUNCTIONS --------------- +CREATE FUNCTION pip_eqn_in(cstring) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_in' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_out(pip_eqn) RETURNS cstring AS 'MODULE_PATHNAME','pip_eqn_out' LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION expectation(pip_eqn, record) RETURNS double precision AS 'MODULE_PATHNAME','pip_expectation' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION expectation(pip_eqn, record, integer) RETURNS double precision AS 'MODULE_PATHNAME','pip_expectation' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION expectation_max_g(pip_sample_set, pip_eqn, record) RETURNS pip_sample_set AS 'MODULE_PATHNAME','pip_expectation_max_g' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION expectation_max_g_one(pip_atomset, double precision, record) RETURNS pip_atomset AS 'MODULE_PATHNAME','pip_expectation_max_g_one' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION expectation_max_f_one(pip_atomset) RETURNS double precision AS 'MODULE_PATHNAME','pip_expectation_max_f_one' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION expectation_sum_g(pip_sample_set, pip_eqn, record) RETURNS pip_sample_set AS 'MODULE_PATHNAME','pip_expectation_sum_g' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION expectation_sum_g_one(double precision, pip_eqn, record) RETURNS double precision AS 'MODULE_PATHNAME','pip_expectation_sum_g_one' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION expectation_sum_g_one(double precision, pip_eqn, record, integer) RETURNS double precision AS 'MODULE_PATHNAME','pip_expectation_sum_g_one' LANGUAGE C VOLATILE STRICT; + +CREATE FUNCTION pip_eqn_sum(pip_eqn,pip_eqn) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_sum_ee' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_sum(pip_eqn,integer) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_sum_ei' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_sum(integer,pip_eqn) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_sum_ie' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_sum(pip_eqn,double precision) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_sum_ef' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_sum(double precision,pip_eqn) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_sum_fe' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_compile_sum(pip_eqn,pip_eqn,record) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_compile_sum' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_compile_sum(pip_eqn,pip_eqn ) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_compile_sum' LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION pip_eqn_mul(pip_eqn,pip_eqn) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_mul_ee' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_mul(pip_eqn,integer) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_mul_ei' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_mul(integer,pip_eqn) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_mul_ie' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_mul(pip_eqn,double precision) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_mul_ef' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_mul(double precision,pip_eqn) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_mul_fe' LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION pip_eqn_neg(pip_eqn) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_neg' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_sub(pip_eqn,pip_eqn) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_sub_ee' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_sub(pip_eqn,integer) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_sub_ei' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_sub(integer,pip_eqn) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_sub_ie' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_sub(pip_eqn,double precision) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_sub_ef' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_sub(double precision,pip_eqn) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_sub_fe' LANGUAGE C IMMUTABLE STRICT; + +--------------- pip_expectation FUNCTIONS --------------- +-- Expectation is a semantic sugar hack to cheat the parser... +-- Consequently the IO operations here are identical to those for pip_eqn +CREATE FUNCTION pip_expectation_in(cstring) RETURNS pip_expectation AS 'MODULE_PATHNAME','pip_exp_in' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_expectation_out(pip_expectation) RETURNS cstring AS 'MODULE_PATHNAME','pip_exp_out' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_expectation_make(pip_eqn) RETURNS pip_expectation AS 'MODULE_PATHNAME','pip_exp_make' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_expectation_fix(pip_expectation,record) RETURNS pip_expectation AS 'MODULE_PATHNAME','pip_exp_fix' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_expectation_expect(pip_expectation) RETURNS double precision AS 'MODULE_PATHNAME','pip_exp_expect' LANGUAGE C IMMUTABLE STRICT; + +--------------- pip_atom FUNCTIONS --------------- +CREATE FUNCTION pip_atom_in(cstring) RETURNS pip_atom AS 'MODULE_PATHNAME','pip_atom_in' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_atom_out(pip_atom) RETURNS cstring AS 'MODULE_PATHNAME','pip_atom_out' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_atom_create_gt(pip_eqn,pip_eqn) RETURNS pip_atom AS 'MODULE_PATHNAME','pip_atom_create_gt_ee' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION pip_atom_create_gt(pip_eqn,double precision) RETURNS pip_atom AS 'MODULE_PATHNAME','pip_atom_create_gt_ef' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION pip_atom_create_gt(double precision,pip_eqn) RETURNS pip_atom AS 'MODULE_PATHNAME','pip_atom_create_gt_fe' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION pip_atom_create_lt(pip_eqn,pip_eqn) RETURNS pip_atom AS 'MODULE_PATHNAME','pip_atom_create_lt_ee' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION pip_atom_create_lt(pip_eqn,double precision) RETURNS pip_atom AS 'MODULE_PATHNAME','pip_atom_create_lt_ef' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION pip_atom_create_lt(double precision,pip_eqn) RETURNS pip_atom AS 'MODULE_PATHNAME','pip_atom_create_lt_fe' LANGUAGE C VOLATILE STRICT; + +--------------- pip_atomset FUNCTIONS --------------- +CREATE FUNCTION pip_atomset_in(cstring) RETURNS pip_atomset AS 'MODULE_PATHNAME','pip_atomset_in' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_atomset_out(pip_atomset) RETURNS cstring AS 'MODULE_PATHNAME','pip_atomset_out' LANGUAGE C IMMUTABLE STRICT; + +--------------- pip_sample_set FUNCTIONS --------------- +CREATE FUNCTION pip_sample_set_in(cstring) RETURNS pip_sample_set AS 'MODULE_PATHNAME','pip_sample_set_in' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_sample_set_out(pip_sample_set) RETURNS cstring AS 'MODULE_PATHNAME','pip_sample_set_out' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_sample_set_generate(record,integer) RETURNS pip_sample_set AS 'MODULE_PATHNAME','pip_sample_set_generate' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION pip_sample_set_explode(pip_sample_set) RETURNS SETOF double precision AS 'MODULE_PATHNAME','pip_sample_set_explode' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_sample_set_expect(pip_sample_set) RETURNS double precision AS 'MODULE_PATHNAME','pip_sample_set_expect' LANGUAGE C IMMUTABLE STRICT; + +--------------- INTEGRATION FUNCTIONS --------------- +CREATE FUNCTION conf_one (record) RETURNS double precision AS 'MODULE_PATHNAME','conf_one' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION conf_sample_g (pip_conf_tally,record,pip_sample_set) RETURNS pip_conf_tally AS 'MODULE_PATHNAME','pip_atom_conf_sample_g' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION conf_naive_g (pip_world_presence,record,pip_sample_set) RETURNS pip_world_presence AS 'MODULE_PATHNAME','pip_atom_sample_set_presence' LANGUAGE C IMMUTABLE STRICT; + +--------------- pip_conf_tally FUNCTIONS --------------- +CREATE FUNCTION pip_conf_tally_in(cstring) RETURNS pip_conf_tally AS 'MODULE_PATHNAME','pip_conf_tally_in' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_conf_tally_out(pip_conf_tally) RETURNS cstring AS 'MODULE_PATHNAME','pip_conf_tally_out' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_conf_tally_result(pip_conf_tally) RETURNS double precision AS 'MODULE_PATHNAME','pip_conf_tally_result' LANGUAGE C IMMUTABLE STRICT; + +--------------- pip_world_presence FUNCTIONS --------------- +CREATE FUNCTION pip_world_presence_in(cstring) RETURNS pip_world_presence AS 'MODULE_PATHNAME','pip_world_presence_in' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_world_presence_out(pip_world_presence) RETURNS cstring AS 'MODULE_PATHNAME','pip_world_presence_out' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_world_presence_create(integer) RETURNS pip_world_presence AS 'MODULE_PATHNAME','pip_world_presence_create' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION pip_world_presence_count(pip_world_presence) RETURNS double precision AS 'MODULE_PATHNAME','pip_world_presence_count' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_world_presence_union(pip_world_presence,pip_world_presence) RETURNS pip_world_presence AS 'MODULE_PATHNAME','pip_world_presence_union' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_world_presence_join(pip_world_presence,pip_world_presence) RETURNS pip_world_presence AS 'MODULE_PATHNAME','pip_world_presence_join' LANGUAGE C IMMUTABLE STRICT; + +--------------- pip_value_bundle FUNCTIONS --------------- +CREATE FUNCTION pip_value_bundle_in(cstring) RETURNS pip_value_bundle AS 'MODULE_PATHNAME','pip_value_bundle_in' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_out(pip_value_bundle) RETURNS cstring AS 'MODULE_PATHNAME','pip_value_bundle_out' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_create(pip_eqn,integer) RETURNS pip_value_bundle AS 'MODULE_PATHNAME','pip_value_bundle_create' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION pip_value_bundle_cmp(pip_world_presence,integer,pip_value_bundle) RETURNS pip_world_presence AS 'MODULE_PATHNAME','pip_value_bundle_cmp_iv' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_cmp(pip_world_presence,double precision,pip_value_bundle) RETURNS pip_world_presence AS 'MODULE_PATHNAME','pip_value_bundle_cmp_fv' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_cmp(pip_world_presence,pip_value_bundle,integer) RETURNS pip_world_presence AS 'MODULE_PATHNAME','pip_value_bundle_cmp_vi' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_cmp(pip_world_presence,pip_value_bundle,double precision) RETURNS pip_world_presence AS 'MODULE_PATHNAME','pip_value_bundle_cmp_vf' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_cmp(pip_world_presence,pip_value_bundle,pip_value_bundle) RETURNS pip_world_presence AS 'MODULE_PATHNAME','pip_value_bundle_cmp_vv' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_add(pip_value_bundle,double precision) RETURNS pip_value_bundle AS 'MODULE_PATHNAME','pip_value_bundle_add_vf' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_add(pip_value_bundle,pip_value_bundle) RETURNS pip_value_bundle AS 'MODULE_PATHNAME','pip_value_bundle_add_vv' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_add(pip_value_bundle,pip_value_bundle,pip_world_presence) RETURNS pip_value_bundle AS 'MODULE_PATHNAME','pip_value_bundle_add_vv' LANGUAGE C IMMUTABLE; +CREATE FUNCTION pip_value_bundle_mul(pip_value_bundle,double precision) RETURNS pip_value_bundle AS 'MODULE_PATHNAME','pip_value_bundle_mul_vf' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_mul(pip_value_bundle,pip_value_bundle) RETURNS pip_value_bundle AS 'MODULE_PATHNAME','pip_value_bundle_mul_vv' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_max(pip_value_bundle,pip_value_bundle) RETURNS pip_value_bundle AS 'MODULE_PATHNAME','pip_value_bundle_max' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_expect(pip_value_bundle) RETURNS double precision AS 'MODULE_PATHNAME','pip_value_bundle_expect' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_expect(pip_value_bundle,pip_world_presence) RETURNS double precision AS 'MODULE_PATHNAME','pip_value_bundle_expect' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_expect(pip_value_bundle,integer,integer) RETURNS double precision AS 'MODULE_PATHNAME','pip_value_bundle_expect' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_expect(pip_value_bundle,integer,integer,pip_world_presence) RETURNS double precision AS 'MODULE_PATHNAME','pip_value_bundle_expect' LANGUAGE C IMMUTABLE STRICT; + +--------------- DEBUG/TEST FUNCTIONS --------------- +CREATE FUNCTION pip_cdf_enabled(integer) RETURNS integer AS 'MODULE_PATHNAME','pip_set_cdf_sampling_enabled' LANGUAGE C IMMUTABLE STRICT; + +--------------- VARIABLE DEFINITIONS --------------- +CREATE TYPE pip_var ( + INPUT = pip_var_in, + OUTPUT = pip_var_out, + STORAGE = external +); +CREATE TYPE pip_atom ( + INPUT = pip_atom_in, + OUTPUT = pip_atom_out, + STORAGE = external +); +CREATE TYPE pip_sample_set ( + INPUT = pip_sample_set_in, + OUTPUT = pip_sample_set_out, + STORAGE = external +); +CREATE TYPE pip_conf_tally ( + INPUT = pip_conf_tally_in, + OUTPUT = pip_conf_tally_out, + STORAGE = external +); +CREATE TYPE pip_value_bundle ( + INPUT = pip_value_bundle_in, + OUTPUT = pip_value_bundle_out, + STORAGE = external +); +CREATE TYPE pip_world_presence ( + INPUT = pip_world_presence_in, + OUTPUT = pip_world_presence_out, + STORAGE = external +); +CREATE TYPE pip_eqn ( + INPUT = pip_eqn_in, + OUTPUT = pip_eqn_out, + STORAGE = external +); +CREATE TYPE pip_expectation ( + INPUT = pip_expectation_in, + OUTPUT = pip_expectation_out, + STORAGE = external +); +CREATE TYPE pip_atomset ( + INPUT = pip_atomset_in, + OUTPUT = pip_atomset_out, + STORAGE = external +); + +--------------- AGGREGATE FUNCTIONS --------------- +CREATE AGGREGATE expectation_max (pip_eqn, record) +( + sfunc = expectation_max_g, + stype = pip_sample_set, + finalfunc = pip_sample_set_expect, + initcond = '?1000/1' +); +CREATE AGGREGATE expectation_max_hist (pip_eqn, record) +( + sfunc = expectation_max_g, + stype = pip_sample_set, + initcond = '?1000/1' +); + +CREATE AGGREGATE expectation_sum (pip_eqn, record, integer) +( + sfunc = expectation_sum_g_one, + stype = double precision, + initcond = '0.0' +); +CREATE AGGREGATE expectation_sum (pip_eqn, record) +( + sfunc = expectation_sum_g_one, + stype = double precision, + initcond = '0.0' +); +CREATE AGGREGATE expectation_sum_hist (pip_eqn, record) +( + sfunc = expectation_sum_g, + stype = pip_sample_set, + initcond = '?1000/1' +); + +CREATE AGGREGATE conf_sample (record,pip_sample_set) +( + sfunc = conf_sample_g, + stype = pip_conf_tally, + finalfunc = pip_conf_tally_result, + initcond = '0:0' +); + +CREATE AGGREGATE pip_world_presence_union (pip_world_presence) +( + sfunc = pip_world_presence_union, + stype = pip_world_presence +); + +CREATE AGGREGATE conf_naive (record,pip_sample_set) +( + sfunc = conf_naive_g, + stype = pip_world_presence, + finalfunc = pip_world_presence_count, + initcond = '?0' +); +CREATE AGGREGATE sum (pip_value_bundle) +( + sfunc = pip_value_bundle_add, + stype = pip_value_bundle +); +CREATE AGGREGATE sum (pip_value_bundle,pip_world_presence) +( + sfunc = pip_value_bundle_add, + stype = pip_value_bundle +); +CREATE AGGREGATE expectation_max (pip_value_bundle) +( + sfunc = pip_value_bundle_max, + stype = pip_value_bundle, + finalfunc = pip_value_bundle_expect +); +CREATE AGGREGATE max(double precision, record) +( + sfunc = expectation_max_g_one, + stype = pip_atomset, + finalfunc = expectation_max_f_one, + initcond = '?8' +-- sortop = > +); +CREATE AGGREGATE sum(pip_eqn) +( + --We label this as a constraint type, since it can be applied on + --constrained columns... the corresponding constraints are pulled into the eqn. + sfunc = pip_eqn_compile_sum, + stype = pip_eqn, + initcond = '(0)' +); + +--------------- FUNCTIONS IN SQL --------------- +CREATE FUNCTION create_variable(varchar, anyelement) RETURNS pip_eqn AS $$ + SELECT create_variable(cast($1 as cstring), cast(nextval('pip_var_id') as integer), $2); + $$ LANGUAGE SQL VOLATILE STRICT; + +--------------- VARIABLE OPERATORS --------------- +CREATE OPERATOR + ( PROCEDURE=pip_eqn_sum, LEFTARG=pip_eqn , RIGHTARG=pip_eqn ); +CREATE OPERATOR + ( PROCEDURE=pip_eqn_sum, LEFTARG=integer , RIGHTARG=pip_eqn ); +CREATE OPERATOR + ( PROCEDURE=pip_eqn_sum, LEFTARG=pip_eqn , RIGHTARG=integer ); +CREATE OPERATOR + ( PROCEDURE=pip_eqn_sum, LEFTARG=double precision, RIGHTARG=pip_eqn ); +CREATE OPERATOR + ( PROCEDURE=pip_eqn_sum, LEFTARG=pip_eqn , RIGHTARG=double precision ); + +CREATE OPERATOR * ( PROCEDURE=pip_eqn_mul, LEFTARG=pip_eqn , RIGHTARG=pip_eqn ); +CREATE OPERATOR * ( PROCEDURE=pip_eqn_mul, LEFTARG=integer , RIGHTARG=pip_eqn ); +CREATE OPERATOR * ( PROCEDURE=pip_eqn_mul, LEFTARG=pip_eqn , RIGHTARG=integer ); +CREATE OPERATOR * ( PROCEDURE=pip_eqn_mul, LEFTARG=double precision, RIGHTARG=pip_eqn ); +CREATE OPERATOR * ( PROCEDURE=pip_eqn_mul, LEFTARG=pip_eqn , RIGHTARG=double precision ); + +CREATE OPERATOR - ( PROCEDURE=pip_eqn_sub, LEFTARG=pip_eqn , RIGHTARG=pip_eqn ); +CREATE OPERATOR - ( PROCEDURE=pip_eqn_sub, LEFTARG=integer , RIGHTARG=pip_eqn ); +CREATE OPERATOR - ( PROCEDURE=pip_eqn_sub, LEFTARG=pip_eqn , RIGHTARG=integer ); +CREATE OPERATOR - ( PROCEDURE=pip_eqn_sub, LEFTARG=double precision, RIGHTARG=pip_eqn ); +CREATE OPERATOR - ( PROCEDURE=pip_eqn_sub, LEFTARG=pip_eqn , RIGHTARG=double precision ); + +CREATE OPERATOR | ( PROCEDURE=pip_world_presence_union, LEFTARG=pip_world_presence, RIGHTARG=pip_world_presence ); + +CREATE OPERATOR > ( PROCEDURE=pip_atom_create_gt, LEFTARG=pip_eqn, RIGHTARG=pip_eqn ); +CREATE OPERATOR > ( PROCEDURE=pip_atom_create_gt, LEFTARG=double precision, RIGHTARG=pip_eqn ); +CREATE OPERATOR > ( PROCEDURE=pip_atom_create_gt, LEFTARG=pip_eqn, RIGHTARG=double precision ); +CREATE OPERATOR < ( PROCEDURE=pip_atom_create_lt, LEFTARG=pip_eqn, RIGHTARG=pip_eqn ); +CREATE OPERATOR < ( PROCEDURE=pip_atom_create_lt, LEFTARG=pip_eqn, RIGHTARG=double precision ); +CREATE OPERATOR < ( PROCEDURE=pip_atom_create_lt, LEFTARG=double precision, RIGHTARG=pip_eqn ); + +--------------- SEMANTIC SUGAR OPERATORS --------------- +CREATE OPERATOR << ( PROCEDURE=pip_expectation_make, RIGHTARG=pip_eqn ); +CREATE OPERATOR @ ( PROCEDURE=pip_expectation_fix, LEFTARG=pip_expectation, RIGHTARG=record ); +CREATE OPERATOR >> ( PROCEDURE=pip_expectation_expect, LEFTARG=pip_expectation ); diff --git a/pip_plugin/pip-test.sql b/pip_plugin/pip-test.sql new file mode 100644 index 0000000..85c3126 --- /dev/null +++ b/pip_plugin/pip-test.sql @@ -0,0 +1,308 @@ +CREATE SEQUENCE pip_var_id; + +--------------- VARIABLE PREDECLARATIONS --------------- +CREATE TYPE pip_var; +CREATE TYPE pip_atom; +CREATE TYPE pip_sample_set; +CREATE TYPE pip_conf_tally; +CREATE TYPE pip_value_bundle; +CREATE TYPE pip_world_presence; +CREATE TYPE pip_eqn; +CREATE TYPE pip_expectation; +CREATE TYPE pip_atomset; + +--------------- pip_var FUNCTIONS --------------- +CREATE FUNCTION pip_var_in(cstring) RETURNS pip_var AS '$libdir/pip-test','pip_var_in' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_var_out(pip_var) RETURNS cstring AS '$libdir/pip-test','pip_var_out' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION create_variable(cstring, integer, cstring) RETURNS pip_eqn AS '$libdir/pip-test','pip_var_create_str' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION create_variable(cstring, integer, record) RETURNS pip_eqn AS '$libdir/pip-test','pip_var_create_row' LANGUAGE C VOLATILE STRICT; + +--------------- pip_eqn FUNCTIONS --------------- +CREATE FUNCTION pip_eqn_in(cstring) RETURNS pip_eqn AS '$libdir/pip-test','pip_eqn_in' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_out(pip_eqn) RETURNS cstring AS '$libdir/pip-test','pip_eqn_out' LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION expectation(pip_eqn, record) RETURNS double precision AS '$libdir/pip-test','pip_expectation' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION expectation(pip_eqn, record, integer) RETURNS double precision AS '$libdir/pip-test','pip_expectation' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION expectation_max_g(pip_sample_set, pip_eqn, record) RETURNS pip_sample_set AS '$libdir/pip-test','pip_expectation_max_g' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION expectation_max_g_one(pip_atomset, double precision, record) RETURNS pip_atomset AS '$libdir/pip-test','pip_expectation_max_g_one' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION expectation_max_f_one(pip_atomset) RETURNS double precision AS '$libdir/pip-test','pip_expectation_max_f_one' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION expectation_sum_g(pip_sample_set, pip_eqn, record) RETURNS pip_sample_set AS '$libdir/pip-test','pip_expectation_sum_g' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION expectation_sum_g_one(double precision, pip_eqn, record) RETURNS double precision AS '$libdir/pip-test','pip_expectation_sum_g_one' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION expectation_sum_g_one(double precision, pip_eqn, record, integer) RETURNS double precision AS '$libdir/pip-test','pip_expectation_sum_g_one' LANGUAGE C VOLATILE STRICT; + +CREATE FUNCTION pip_eqn_sum(pip_eqn,pip_eqn) RETURNS pip_eqn AS '$libdir/pip-test','pip_eqn_sum_ee' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_sum(pip_eqn,integer) RETURNS pip_eqn AS '$libdir/pip-test','pip_eqn_sum_ei' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_sum(integer,pip_eqn) RETURNS pip_eqn AS '$libdir/pip-test','pip_eqn_sum_ie' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_sum(pip_eqn,double precision) RETURNS pip_eqn AS '$libdir/pip-test','pip_eqn_sum_ef' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_sum(double precision,pip_eqn) RETURNS pip_eqn AS '$libdir/pip-test','pip_eqn_sum_fe' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_compile_sum(pip_eqn,pip_eqn,record) RETURNS pip_eqn AS '$libdir/pip-test','pip_eqn_compile_sum' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_compile_sum(pip_eqn,pip_eqn ) RETURNS pip_eqn AS '$libdir/pip-test','pip_eqn_compile_sum' LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION pip_eqn_mul(pip_eqn,pip_eqn) RETURNS pip_eqn AS '$libdir/pip-test','pip_eqn_mul_ee' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_mul(pip_eqn,integer) RETURNS pip_eqn AS '$libdir/pip-test','pip_eqn_mul_ei' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_mul(integer,pip_eqn) RETURNS pip_eqn AS '$libdir/pip-test','pip_eqn_mul_ie' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_mul(pip_eqn,double precision) RETURNS pip_eqn AS '$libdir/pip-test','pip_eqn_mul_ef' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_mul(double precision,pip_eqn) RETURNS pip_eqn AS '$libdir/pip-test','pip_eqn_mul_fe' LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION pip_eqn_neg(pip_eqn) RETURNS pip_eqn AS '$libdir/pip-test','pip_eqn_neg' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_sub(pip_eqn,pip_eqn) RETURNS pip_eqn AS '$libdir/pip-test','pip_eqn_sub_ee' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_sub(pip_eqn,integer) RETURNS pip_eqn AS '$libdir/pip-test','pip_eqn_sub_ei' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_sub(integer,pip_eqn) RETURNS pip_eqn AS '$libdir/pip-test','pip_eqn_sub_ie' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_sub(pip_eqn,double precision) RETURNS pip_eqn AS '$libdir/pip-test','pip_eqn_sub_ef' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_sub(double precision,pip_eqn) RETURNS pip_eqn AS '$libdir/pip-test','pip_eqn_sub_fe' LANGUAGE C IMMUTABLE STRICT; + +--------------- pip_expectation FUNCTIONS --------------- +-- Expectation is a semantic sugar hack to cheat the parser... +-- Consequently the IO operations here are identical to those for pip_eqn +CREATE FUNCTION pip_expectation_in(cstring) RETURNS pip_expectation AS '$libdir/pip-test','pip_exp_in' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_expectation_out(pip_expectation) RETURNS cstring AS '$libdir/pip-test','pip_exp_out' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_expectation_make(pip_eqn) RETURNS pip_expectation AS '$libdir/pip-test','pip_exp_make' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_expectation_fix(pip_expectation,record) RETURNS pip_expectation AS '$libdir/pip-test','pip_exp_fix' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_expectation_expect(pip_expectation) RETURNS double precision AS '$libdir/pip-test','pip_exp_expect' LANGUAGE C IMMUTABLE STRICT; + +--------------- pip_atom FUNCTIONS --------------- +CREATE FUNCTION pip_atom_in(cstring) RETURNS pip_atom AS '$libdir/pip-test','pip_atom_in' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_atom_out(pip_atom) RETURNS cstring AS '$libdir/pip-test','pip_atom_out' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_atom_create_gt(pip_eqn,pip_eqn) RETURNS pip_atom AS '$libdir/pip-test','pip_atom_create_gt_ee' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION pip_atom_create_gt(pip_eqn,double precision) RETURNS pip_atom AS '$libdir/pip-test','pip_atom_create_gt_ef' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION pip_atom_create_gt(double precision,pip_eqn) RETURNS pip_atom AS '$libdir/pip-test','pip_atom_create_gt_fe' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION pip_atom_create_lt(pip_eqn,pip_eqn) RETURNS pip_atom AS '$libdir/pip-test','pip_atom_create_lt_ee' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION pip_atom_create_lt(pip_eqn,double precision) RETURNS pip_atom AS '$libdir/pip-test','pip_atom_create_lt_ef' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION pip_atom_create_lt(double precision,pip_eqn) RETURNS pip_atom AS '$libdir/pip-test','pip_atom_create_lt_fe' LANGUAGE C VOLATILE STRICT; + +--------------- pip_atomset FUNCTIONS --------------- +CREATE FUNCTION pip_atomset_in(cstring) RETURNS pip_atomset AS '$libdir/pip-test','pip_atomset_in' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_atomset_out(pip_atomset) RETURNS cstring AS '$libdir/pip-test','pip_atomset_out' LANGUAGE C IMMUTABLE STRICT; + +--------------- pip_sample_set FUNCTIONS --------------- +CREATE FUNCTION pip_sample_set_in(cstring) RETURNS pip_sample_set AS '$libdir/pip-test','pip_sample_set_in' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_sample_set_out(pip_sample_set) RETURNS cstring AS '$libdir/pip-test','pip_sample_set_out' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_sample_set_generate(record,integer) RETURNS pip_sample_set AS '$libdir/pip-test','pip_sample_set_generate' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION pip_sample_set_explode(pip_sample_set) RETURNS SETOF double precision AS '$libdir/pip-test','pip_sample_set_explode' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_sample_set_expect(pip_sample_set) RETURNS double precision AS '$libdir/pip-test','pip_sample_set_expect' LANGUAGE C IMMUTABLE STRICT; + +--------------- INTEGRATION FUNCTIONS --------------- +CREATE FUNCTION conf_one (record) RETURNS double precision AS '$libdir/pip-test','conf_one' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION conf_sample_g (pip_conf_tally,record,pip_sample_set) RETURNS pip_conf_tally AS '$libdir/pip-test','pip_atom_conf_sample_g' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION conf_naive_g (pip_world_presence,record,pip_sample_set) RETURNS pip_world_presence AS '$libdir/pip-test','pip_atom_sample_set_presence' LANGUAGE C IMMUTABLE STRICT; + +--------------- pip_conf_tally FUNCTIONS --------------- +CREATE FUNCTION pip_conf_tally_in(cstring) RETURNS pip_conf_tally AS '$libdir/pip-test','pip_conf_tally_in' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_conf_tally_out(pip_conf_tally) RETURNS cstring AS '$libdir/pip-test','pip_conf_tally_out' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_conf_tally_result(pip_conf_tally) RETURNS double precision AS '$libdir/pip-test','pip_conf_tally_result' LANGUAGE C IMMUTABLE STRICT; + +--------------- pip_world_presence FUNCTIONS --------------- +CREATE FUNCTION pip_world_presence_in(cstring) RETURNS pip_world_presence AS '$libdir/pip-test','pip_world_presence_in' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_world_presence_out(pip_world_presence) RETURNS cstring AS '$libdir/pip-test','pip_world_presence_out' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_world_presence_create(integer) RETURNS pip_world_presence AS '$libdir/pip-test','pip_world_presence_create' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION pip_world_presence_count(pip_world_presence) RETURNS double precision AS '$libdir/pip-test','pip_world_presence_count' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_world_presence_union(pip_world_presence,pip_world_presence) RETURNS pip_world_presence AS '$libdir/pip-test','pip_world_presence_union' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_world_presence_join(pip_world_presence,pip_world_presence) RETURNS pip_world_presence AS '$libdir/pip-test','pip_world_presence_join' LANGUAGE C IMMUTABLE STRICT; + +--------------- pip_value_bundle FUNCTIONS --------------- +CREATE FUNCTION pip_value_bundle_in(cstring) RETURNS pip_value_bundle AS '$libdir/pip-test','pip_value_bundle_in' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_out(pip_value_bundle) RETURNS cstring AS '$libdir/pip-test','pip_value_bundle_out' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_create(pip_eqn,integer) RETURNS pip_value_bundle AS '$libdir/pip-test','pip_value_bundle_create' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION pip_value_bundle_cmp(pip_world_presence,integer,pip_value_bundle) RETURNS pip_world_presence AS '$libdir/pip-test','pip_value_bundle_cmp_iv' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_cmp(pip_world_presence,double precision,pip_value_bundle) RETURNS pip_world_presence AS '$libdir/pip-test','pip_value_bundle_cmp_fv' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_cmp(pip_world_presence,pip_value_bundle,integer) RETURNS pip_world_presence AS '$libdir/pip-test','pip_value_bundle_cmp_vi' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_cmp(pip_world_presence,pip_value_bundle,double precision) RETURNS pip_world_presence AS '$libdir/pip-test','pip_value_bundle_cmp_vf' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_cmp(pip_world_presence,pip_value_bundle,pip_value_bundle) RETURNS pip_world_presence AS '$libdir/pip-test','pip_value_bundle_cmp_vv' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_add(pip_value_bundle,double precision) RETURNS pip_value_bundle AS '$libdir/pip-test','pip_value_bundle_add_vf' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_add(pip_value_bundle,pip_value_bundle) RETURNS pip_value_bundle AS '$libdir/pip-test','pip_value_bundle_add_vv' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_add(pip_value_bundle,pip_value_bundle,pip_world_presence) RETURNS pip_value_bundle AS '$libdir/pip-test','pip_value_bundle_add_vv' LANGUAGE C IMMUTABLE; +CREATE FUNCTION pip_value_bundle_mul(pip_value_bundle,double precision) RETURNS pip_value_bundle AS '$libdir/pip-test','pip_value_bundle_mul_vf' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_mul(pip_value_bundle,pip_value_bundle) RETURNS pip_value_bundle AS '$libdir/pip-test','pip_value_bundle_mul_vv' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_max(pip_value_bundle,pip_value_bundle) RETURNS pip_value_bundle AS '$libdir/pip-test','pip_value_bundle_max' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_expect(pip_value_bundle) RETURNS double precision AS '$libdir/pip-test','pip_value_bundle_expect' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_expect(pip_value_bundle,pip_world_presence) RETURNS double precision AS '$libdir/pip-test','pip_value_bundle_expect' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_expect(pip_value_bundle,integer,integer) RETURNS double precision AS '$libdir/pip-test','pip_value_bundle_expect' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_expect(pip_value_bundle,integer,integer,pip_world_presence) RETURNS double precision AS '$libdir/pip-test','pip_value_bundle_expect' LANGUAGE C IMMUTABLE STRICT; + +--------------- DEBUG/TEST FUNCTIONS --------------- +CREATE FUNCTION pip_cdf_enabled(integer) RETURNS integer AS '$libdir/pip-test','pip_set_cdf_sampling_enabled' LANGUAGE C IMMUTABLE STRICT; + +--------------- VARIABLE DEFINITIONS --------------- +CREATE TYPE pip_var ( + INPUT = pip_var_in, + OUTPUT = pip_var_out, + STORAGE = external +); +CREATE TYPE pip_atom ( + INPUT = pip_atom_in, + OUTPUT = pip_atom_out, + CONSTRAINTTYPE, --HACKED_SQL_ONLY + STORAGE = external +); +CREATE TYPE pip_sample_set ( + INPUT = pip_sample_set_in, + OUTPUT = pip_sample_set_out, + STORAGE = external +); +CREATE TYPE pip_conf_tally ( + INPUT = pip_conf_tally_in, + OUTPUT = pip_conf_tally_out, + STORAGE = external +); +CREATE TYPE pip_value_bundle ( + INPUT = pip_value_bundle_in, + OUTPUT = pip_value_bundle_out, + STORAGE = external +); +CREATE TYPE pip_world_presence ( + INPUT = pip_world_presence_in, + OUTPUT = pip_world_presence_out, + STORAGE = external +); +CREATE TYPE pip_eqn ( + INPUT = pip_eqn_in, + OUTPUT = pip_eqn_out, + STORAGE = external +); +CREATE TYPE pip_expectation ( + INPUT = pip_expectation_in, + OUTPUT = pip_expectation_out, + STORAGE = external +); +CREATE TYPE pip_atomset ( + INPUT = pip_atomset_in, + OUTPUT = pip_atomset_out, + STORAGE = external +); + +--------------- AGGREGATE FUNCTIONS --------------- +CREATE AGGREGATE expectation_max (pip_eqn, record) +( + CONSTRAINTTYPE, --HACKED_SQL_ONLY + sfunc = expectation_max_g, + stype = pip_sample_set, + finalfunc = pip_sample_set_expect, + initcond = '?1000/1' +); +CREATE AGGREGATE expectation_max_hist (pip_eqn, record) +( + CONSTRAINTTYPE, --HACKED_SQL_ONLY + sfunc = expectation_max_g, + stype = pip_sample_set, + initcond = '?1000/1' +); + +CREATE AGGREGATE expectation_sum (pip_eqn, record, integer) +( + CONSTRAINTTYPE, --HACKED_SQL_ONLY + sfunc = expectation_sum_g_one, + stype = double precision, + initcond = '0.0' +); +CREATE AGGREGATE expectation_sum (pip_eqn, record) +( + CONSTRAINTTYPE, --HACKED_SQL_ONLY + sfunc = expectation_sum_g_one, + stype = double precision, + initcond = '0.0' +); +CREATE AGGREGATE expectation_sum_hist (pip_eqn, record) +( + CONSTRAINTTYPE, --HACKED_SQL_ONLY + sfunc = expectation_sum_g, + stype = pip_sample_set, + initcond = '?1000/1' +); + +CREATE AGGREGATE conf_sample (record,pip_sample_set) +( + CONSTRAINTTYPE, --HACKED_SQL_ONLY + sfunc = conf_sample_g, + stype = pip_conf_tally, + finalfunc = pip_conf_tally_result, + initcond = '0:0' +); + +CREATE AGGREGATE pip_world_presence_union (pip_world_presence) +( + CONSTRAINTTYPE, --HACKED_SQL_ONLY + sfunc = pip_world_presence_union, + stype = pip_world_presence +); + +CREATE AGGREGATE conf_naive (record,pip_sample_set) +( + CONSTRAINTTYPE, --HACKED_SQL_ONLY + sfunc = conf_naive_g, + stype = pip_world_presence, + finalfunc = pip_world_presence_count, + initcond = '?0' +); +CREATE AGGREGATE sum (pip_value_bundle) +( + sfunc = pip_value_bundle_add, + stype = pip_value_bundle +); +CREATE AGGREGATE sum (pip_value_bundle,pip_world_presence) +( + sfunc = pip_value_bundle_add, + stype = pip_value_bundle +); +CREATE AGGREGATE expectation_max (pip_value_bundle) +( + CONSTRAINTTYPE, --HACKED_SQL_ONLY + sfunc = pip_value_bundle_max, + stype = pip_value_bundle, + finalfunc = pip_value_bundle_expect +); +CREATE AGGREGATE max(double precision, record) +( + CONSTRAINTTYPE, --HACKED_SQL_ONLY + sfunc = expectation_max_g_one, + stype = pip_atomset, + finalfunc = expectation_max_f_one, + initcond = '?8' +-- sortop = > +); +CREATE AGGREGATE sum(pip_eqn) +( + --We label this as a constraint type, since it can be applied on + --constrained columns... the corresponding constraints are pulled into the eqn. + CONSTRAINTTYPE, --HACKED_SQL_ONLY + sfunc = pip_eqn_compile_sum, + stype = pip_eqn, + initcond = '(0)' +); + +--------------- FUNCTIONS IN SQL --------------- +CREATE FUNCTION create_variable(varchar, anyelement) RETURNS pip_eqn AS $$ + SELECT create_variable(cast($1 as cstring), cast(nextval('pip_var_id') as integer), $2); + $$ LANGUAGE SQL VOLATILE STRICT; + +--------------- VARIABLE OPERATORS --------------- +CREATE OPERATOR + ( PROCEDURE=pip_eqn_sum, LEFTARG=pip_eqn , RIGHTARG=pip_eqn ); +CREATE OPERATOR + ( PROCEDURE=pip_eqn_sum, LEFTARG=integer , RIGHTARG=pip_eqn ); +CREATE OPERATOR + ( PROCEDURE=pip_eqn_sum, LEFTARG=pip_eqn , RIGHTARG=integer ); +CREATE OPERATOR + ( PROCEDURE=pip_eqn_sum, LEFTARG=double precision, RIGHTARG=pip_eqn ); +CREATE OPERATOR + ( PROCEDURE=pip_eqn_sum, LEFTARG=pip_eqn , RIGHTARG=double precision ); + +CREATE OPERATOR * ( PROCEDURE=pip_eqn_mul, LEFTARG=pip_eqn , RIGHTARG=pip_eqn ); +CREATE OPERATOR * ( PROCEDURE=pip_eqn_mul, LEFTARG=integer , RIGHTARG=pip_eqn ); +CREATE OPERATOR * ( PROCEDURE=pip_eqn_mul, LEFTARG=pip_eqn , RIGHTARG=integer ); +CREATE OPERATOR * ( PROCEDURE=pip_eqn_mul, LEFTARG=double precision, RIGHTARG=pip_eqn ); +CREATE OPERATOR * ( PROCEDURE=pip_eqn_mul, LEFTARG=pip_eqn , RIGHTARG=double precision ); + +CREATE OPERATOR - ( PROCEDURE=pip_eqn_sub, LEFTARG=pip_eqn , RIGHTARG=pip_eqn ); +CREATE OPERATOR - ( PROCEDURE=pip_eqn_sub, LEFTARG=integer , RIGHTARG=pip_eqn ); +CREATE OPERATOR - ( PROCEDURE=pip_eqn_sub, LEFTARG=pip_eqn , RIGHTARG=integer ); +CREATE OPERATOR - ( PROCEDURE=pip_eqn_sub, LEFTARG=double precision, RIGHTARG=pip_eqn ); +CREATE OPERATOR - ( PROCEDURE=pip_eqn_sub, LEFTARG=pip_eqn , RIGHTARG=double precision ); + +CREATE OPERATOR | ( PROCEDURE=pip_world_presence_union, LEFTARG=pip_world_presence, RIGHTARG=pip_world_presence ); + +CREATE OPERATOR > ( PROCEDURE=pip_atom_create_gt, LEFTARG=pip_eqn, RIGHTARG=pip_eqn ); +CREATE OPERATOR > ( PROCEDURE=pip_atom_create_gt, LEFTARG=double precision, RIGHTARG=pip_eqn ); +CREATE OPERATOR > ( PROCEDURE=pip_atom_create_gt, LEFTARG=pip_eqn, RIGHTARG=double precision ); +CREATE OPERATOR < ( PROCEDURE=pip_atom_create_lt, LEFTARG=pip_eqn, RIGHTARG=pip_eqn ); +CREATE OPERATOR < ( PROCEDURE=pip_atom_create_lt, LEFTARG=pip_eqn, RIGHTARG=double precision ); +CREATE OPERATOR < ( PROCEDURE=pip_atom_create_lt, LEFTARG=double precision, RIGHTARG=pip_eqn ); + +--------------- SEMANTIC SUGAR OPERATORS --------------- +CREATE OPERATOR << ( PROCEDURE=pip_expectation_make, RIGHTARG=pip_eqn ); +CREATE OPERATOR @ ( PROCEDURE=pip_expectation_fix, LEFTARG=pip_expectation, RIGHTARG=record ); +CREATE OPERATOR >> ( PROCEDURE=pip_expectation_expect, LEFTARG=pip_expectation ); diff --git a/pip_plugin/pip-test.sql.in b/pip_plugin/pip-test.sql.in new file mode 100644 index 0000000..0068bce --- /dev/null +++ b/pip_plugin/pip-test.sql.in @@ -0,0 +1,308 @@ +CREATE SEQUENCE pip_var_id; + +--------------- VARIABLE PREDECLARATIONS --------------- +CREATE TYPE pip_var; +CREATE TYPE pip_atom; +CREATE TYPE pip_sample_set; +CREATE TYPE pip_conf_tally; +CREATE TYPE pip_value_bundle; +CREATE TYPE pip_world_presence; +CREATE TYPE pip_eqn; +CREATE TYPE pip_expectation; +CREATE TYPE pip_atomset; + +--------------- pip_var FUNCTIONS --------------- +CREATE FUNCTION pip_var_in(cstring) RETURNS pip_var AS 'MODULE_PATHNAME','pip_var_in' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_var_out(pip_var) RETURNS cstring AS 'MODULE_PATHNAME','pip_var_out' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION create_variable(cstring, integer, cstring) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_var_create_str' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION create_variable(cstring, integer, record) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_var_create_row' LANGUAGE C VOLATILE STRICT; + +--------------- pip_eqn FUNCTIONS --------------- +CREATE FUNCTION pip_eqn_in(cstring) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_in' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_out(pip_eqn) RETURNS cstring AS 'MODULE_PATHNAME','pip_eqn_out' LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION expectation(pip_eqn, record) RETURNS double precision AS 'MODULE_PATHNAME','pip_expectation' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION expectation(pip_eqn, record, integer) RETURNS double precision AS 'MODULE_PATHNAME','pip_expectation' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION expectation_max_g(pip_sample_set, pip_eqn, record) RETURNS pip_sample_set AS 'MODULE_PATHNAME','pip_expectation_max_g' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION expectation_max_g_one(pip_atomset, double precision, record) RETURNS pip_atomset AS 'MODULE_PATHNAME','pip_expectation_max_g_one' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION expectation_max_f_one(pip_atomset) RETURNS double precision AS 'MODULE_PATHNAME','pip_expectation_max_f_one' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION expectation_sum_g(pip_sample_set, pip_eqn, record) RETURNS pip_sample_set AS 'MODULE_PATHNAME','pip_expectation_sum_g' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION expectation_sum_g_one(double precision, pip_eqn, record) RETURNS double precision AS 'MODULE_PATHNAME','pip_expectation_sum_g_one' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION expectation_sum_g_one(double precision, pip_eqn, record, integer) RETURNS double precision AS 'MODULE_PATHNAME','pip_expectation_sum_g_one' LANGUAGE C VOLATILE STRICT; + +CREATE FUNCTION pip_eqn_sum(pip_eqn,pip_eqn) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_sum_ee' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_sum(pip_eqn,integer) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_sum_ei' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_sum(integer,pip_eqn) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_sum_ie' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_sum(pip_eqn,double precision) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_sum_ef' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_sum(double precision,pip_eqn) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_sum_fe' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_compile_sum(pip_eqn,pip_eqn,record) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_compile_sum' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_compile_sum(pip_eqn,pip_eqn ) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_compile_sum' LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION pip_eqn_mul(pip_eqn,pip_eqn) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_mul_ee' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_mul(pip_eqn,integer) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_mul_ei' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_mul(integer,pip_eqn) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_mul_ie' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_mul(pip_eqn,double precision) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_mul_ef' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_mul(double precision,pip_eqn) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_mul_fe' LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION pip_eqn_neg(pip_eqn) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_neg' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_sub(pip_eqn,pip_eqn) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_sub_ee' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_sub(pip_eqn,integer) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_sub_ei' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_sub(integer,pip_eqn) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_sub_ie' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_sub(pip_eqn,double precision) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_sub_ef' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_sub(double precision,pip_eqn) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_sub_fe' LANGUAGE C IMMUTABLE STRICT; + +--------------- pip_expectation FUNCTIONS --------------- +-- Expectation is a semantic sugar hack to cheat the parser... +-- Consequently the IO operations here are identical to those for pip_eqn +CREATE FUNCTION pip_expectation_in(cstring) RETURNS pip_expectation AS 'MODULE_PATHNAME','pip_exp_in' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_expectation_out(pip_expectation) RETURNS cstring AS 'MODULE_PATHNAME','pip_exp_out' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_expectation_make(pip_eqn) RETURNS pip_expectation AS 'MODULE_PATHNAME','pip_exp_make' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_expectation_fix(pip_expectation,record) RETURNS pip_expectation AS 'MODULE_PATHNAME','pip_exp_fix' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_expectation_expect(pip_expectation) RETURNS double precision AS 'MODULE_PATHNAME','pip_exp_expect' LANGUAGE C IMMUTABLE STRICT; + +--------------- pip_atom FUNCTIONS --------------- +CREATE FUNCTION pip_atom_in(cstring) RETURNS pip_atom AS 'MODULE_PATHNAME','pip_atom_in' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_atom_out(pip_atom) RETURNS cstring AS 'MODULE_PATHNAME','pip_atom_out' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_atom_create_gt(pip_eqn,pip_eqn) RETURNS pip_atom AS 'MODULE_PATHNAME','pip_atom_create_gt_ee' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION pip_atom_create_gt(pip_eqn,double precision) RETURNS pip_atom AS 'MODULE_PATHNAME','pip_atom_create_gt_ef' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION pip_atom_create_gt(double precision,pip_eqn) RETURNS pip_atom AS 'MODULE_PATHNAME','pip_atom_create_gt_fe' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION pip_atom_create_lt(pip_eqn,pip_eqn) RETURNS pip_atom AS 'MODULE_PATHNAME','pip_atom_create_lt_ee' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION pip_atom_create_lt(pip_eqn,double precision) RETURNS pip_atom AS 'MODULE_PATHNAME','pip_atom_create_lt_ef' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION pip_atom_create_lt(double precision,pip_eqn) RETURNS pip_atom AS 'MODULE_PATHNAME','pip_atom_create_lt_fe' LANGUAGE C VOLATILE STRICT; + +--------------- pip_atomset FUNCTIONS --------------- +CREATE FUNCTION pip_atomset_in(cstring) RETURNS pip_atomset AS 'MODULE_PATHNAME','pip_atomset_in' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_atomset_out(pip_atomset) RETURNS cstring AS 'MODULE_PATHNAME','pip_atomset_out' LANGUAGE C IMMUTABLE STRICT; + +--------------- pip_sample_set FUNCTIONS --------------- +CREATE FUNCTION pip_sample_set_in(cstring) RETURNS pip_sample_set AS 'MODULE_PATHNAME','pip_sample_set_in' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_sample_set_out(pip_sample_set) RETURNS cstring AS 'MODULE_PATHNAME','pip_sample_set_out' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_sample_set_generate(record,integer) RETURNS pip_sample_set AS 'MODULE_PATHNAME','pip_sample_set_generate' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION pip_sample_set_explode(pip_sample_set) RETURNS SETOF double precision AS 'MODULE_PATHNAME','pip_sample_set_explode' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_sample_set_expect(pip_sample_set) RETURNS double precision AS 'MODULE_PATHNAME','pip_sample_set_expect' LANGUAGE C IMMUTABLE STRICT; + +--------------- INTEGRATION FUNCTIONS --------------- +CREATE FUNCTION conf_one (record) RETURNS double precision AS 'MODULE_PATHNAME','conf_one' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION conf_sample_g (pip_conf_tally,record,pip_sample_set) RETURNS pip_conf_tally AS 'MODULE_PATHNAME','pip_atom_conf_sample_g' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION conf_naive_g (pip_world_presence,record,pip_sample_set) RETURNS pip_world_presence AS 'MODULE_PATHNAME','pip_atom_sample_set_presence' LANGUAGE C IMMUTABLE STRICT; + +--------------- pip_conf_tally FUNCTIONS --------------- +CREATE FUNCTION pip_conf_tally_in(cstring) RETURNS pip_conf_tally AS 'MODULE_PATHNAME','pip_conf_tally_in' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_conf_tally_out(pip_conf_tally) RETURNS cstring AS 'MODULE_PATHNAME','pip_conf_tally_out' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_conf_tally_result(pip_conf_tally) RETURNS double precision AS 'MODULE_PATHNAME','pip_conf_tally_result' LANGUAGE C IMMUTABLE STRICT; + +--------------- pip_world_presence FUNCTIONS --------------- +CREATE FUNCTION pip_world_presence_in(cstring) RETURNS pip_world_presence AS 'MODULE_PATHNAME','pip_world_presence_in' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_world_presence_out(pip_world_presence) RETURNS cstring AS 'MODULE_PATHNAME','pip_world_presence_out' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_world_presence_create(integer) RETURNS pip_world_presence AS 'MODULE_PATHNAME','pip_world_presence_create' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION pip_world_presence_count(pip_world_presence) RETURNS double precision AS 'MODULE_PATHNAME','pip_world_presence_count' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_world_presence_union(pip_world_presence,pip_world_presence) RETURNS pip_world_presence AS 'MODULE_PATHNAME','pip_world_presence_union' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_world_presence_join(pip_world_presence,pip_world_presence) RETURNS pip_world_presence AS 'MODULE_PATHNAME','pip_world_presence_join' LANGUAGE C IMMUTABLE STRICT; + +--------------- pip_value_bundle FUNCTIONS --------------- +CREATE FUNCTION pip_value_bundle_in(cstring) RETURNS pip_value_bundle AS 'MODULE_PATHNAME','pip_value_bundle_in' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_out(pip_value_bundle) RETURNS cstring AS 'MODULE_PATHNAME','pip_value_bundle_out' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_create(pip_eqn,integer) RETURNS pip_value_bundle AS 'MODULE_PATHNAME','pip_value_bundle_create' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION pip_value_bundle_cmp(pip_world_presence,integer,pip_value_bundle) RETURNS pip_world_presence AS 'MODULE_PATHNAME','pip_value_bundle_cmp_iv' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_cmp(pip_world_presence,double precision,pip_value_bundle) RETURNS pip_world_presence AS 'MODULE_PATHNAME','pip_value_bundle_cmp_fv' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_cmp(pip_world_presence,pip_value_bundle,integer) RETURNS pip_world_presence AS 'MODULE_PATHNAME','pip_value_bundle_cmp_vi' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_cmp(pip_world_presence,pip_value_bundle,double precision) RETURNS pip_world_presence AS 'MODULE_PATHNAME','pip_value_bundle_cmp_vf' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_cmp(pip_world_presence,pip_value_bundle,pip_value_bundle) RETURNS pip_world_presence AS 'MODULE_PATHNAME','pip_value_bundle_cmp_vv' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_add(pip_value_bundle,double precision) RETURNS pip_value_bundle AS 'MODULE_PATHNAME','pip_value_bundle_add_vf' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_add(pip_value_bundle,pip_value_bundle) RETURNS pip_value_bundle AS 'MODULE_PATHNAME','pip_value_bundle_add_vv' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_add(pip_value_bundle,pip_value_bundle,pip_world_presence) RETURNS pip_value_bundle AS 'MODULE_PATHNAME','pip_value_bundle_add_vv' LANGUAGE C IMMUTABLE; +CREATE FUNCTION pip_value_bundle_mul(pip_value_bundle,double precision) RETURNS pip_value_bundle AS 'MODULE_PATHNAME','pip_value_bundle_mul_vf' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_mul(pip_value_bundle,pip_value_bundle) RETURNS pip_value_bundle AS 'MODULE_PATHNAME','pip_value_bundle_mul_vv' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_max(pip_value_bundle,pip_value_bundle) RETURNS pip_value_bundle AS 'MODULE_PATHNAME','pip_value_bundle_max' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_expect(pip_value_bundle) RETURNS double precision AS 'MODULE_PATHNAME','pip_value_bundle_expect' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_expect(pip_value_bundle,pip_world_presence) RETURNS double precision AS 'MODULE_PATHNAME','pip_value_bundle_expect' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_expect(pip_value_bundle,integer,integer) RETURNS double precision AS 'MODULE_PATHNAME','pip_value_bundle_expect' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_expect(pip_value_bundle,integer,integer,pip_world_presence) RETURNS double precision AS 'MODULE_PATHNAME','pip_value_bundle_expect' LANGUAGE C IMMUTABLE STRICT; + +--------------- DEBUG/TEST FUNCTIONS --------------- +CREATE FUNCTION pip_cdf_enabled(integer) RETURNS integer AS 'MODULE_PATHNAME','pip_set_cdf_sampling_enabled' LANGUAGE C IMMUTABLE STRICT; + +--------------- VARIABLE DEFINITIONS --------------- +CREATE TYPE pip_var ( + INPUT = pip_var_in, + OUTPUT = pip_var_out, + STORAGE = external +); +CREATE TYPE pip_atom ( + INPUT = pip_atom_in, + OUTPUT = pip_atom_out, + CONSTRAINTTYPE, --HACKED_SQL_ONLY + STORAGE = external +); +CREATE TYPE pip_sample_set ( + INPUT = pip_sample_set_in, + OUTPUT = pip_sample_set_out, + STORAGE = external +); +CREATE TYPE pip_conf_tally ( + INPUT = pip_conf_tally_in, + OUTPUT = pip_conf_tally_out, + STORAGE = external +); +CREATE TYPE pip_value_bundle ( + INPUT = pip_value_bundle_in, + OUTPUT = pip_value_bundle_out, + STORAGE = external +); +CREATE TYPE pip_world_presence ( + INPUT = pip_world_presence_in, + OUTPUT = pip_world_presence_out, + STORAGE = external +); +CREATE TYPE pip_eqn ( + INPUT = pip_eqn_in, + OUTPUT = pip_eqn_out, + STORAGE = external +); +CREATE TYPE pip_expectation ( + INPUT = pip_expectation_in, + OUTPUT = pip_expectation_out, + STORAGE = external +); +CREATE TYPE pip_atomset ( + INPUT = pip_atomset_in, + OUTPUT = pip_atomset_out, + STORAGE = external +); + +--------------- AGGREGATE FUNCTIONS --------------- +CREATE AGGREGATE expectation_max (pip_eqn, record) +( + CONSTRAINTTYPE, --HACKED_SQL_ONLY + sfunc = expectation_max_g, + stype = pip_sample_set, + finalfunc = pip_sample_set_expect, + initcond = '?1000/1' +); +CREATE AGGREGATE expectation_max_hist (pip_eqn, record) +( + CONSTRAINTTYPE, --HACKED_SQL_ONLY + sfunc = expectation_max_g, + stype = pip_sample_set, + initcond = '?1000/1' +); + +CREATE AGGREGATE expectation_sum (pip_eqn, record, integer) +( + CONSTRAINTTYPE, --HACKED_SQL_ONLY + sfunc = expectation_sum_g_one, + stype = double precision, + initcond = '0.0' +); +CREATE AGGREGATE expectation_sum (pip_eqn, record) +( + CONSTRAINTTYPE, --HACKED_SQL_ONLY + sfunc = expectation_sum_g_one, + stype = double precision, + initcond = '0.0' +); +CREATE AGGREGATE expectation_sum_hist (pip_eqn, record) +( + CONSTRAINTTYPE, --HACKED_SQL_ONLY + sfunc = expectation_sum_g, + stype = pip_sample_set, + initcond = '?1000/1' +); + +CREATE AGGREGATE conf_sample (record,pip_sample_set) +( + CONSTRAINTTYPE, --HACKED_SQL_ONLY + sfunc = conf_sample_g, + stype = pip_conf_tally, + finalfunc = pip_conf_tally_result, + initcond = '0:0' +); + +CREATE AGGREGATE pip_world_presence_union (pip_world_presence) +( + CONSTRAINTTYPE, --HACKED_SQL_ONLY + sfunc = pip_world_presence_union, + stype = pip_world_presence +); + +CREATE AGGREGATE conf_naive (record,pip_sample_set) +( + CONSTRAINTTYPE, --HACKED_SQL_ONLY + sfunc = conf_naive_g, + stype = pip_world_presence, + finalfunc = pip_world_presence_count, + initcond = '?0' +); +CREATE AGGREGATE sum (pip_value_bundle) +( + sfunc = pip_value_bundle_add, + stype = pip_value_bundle +); +CREATE AGGREGATE sum (pip_value_bundle,pip_world_presence) +( + sfunc = pip_value_bundle_add, + stype = pip_value_bundle +); +CREATE AGGREGATE expectation_max (pip_value_bundle) +( + CONSTRAINTTYPE, --HACKED_SQL_ONLY + sfunc = pip_value_bundle_max, + stype = pip_value_bundle, + finalfunc = pip_value_bundle_expect +); +CREATE AGGREGATE max(double precision, record) +( + CONSTRAINTTYPE, --HACKED_SQL_ONLY + sfunc = expectation_max_g_one, + stype = pip_atomset, + finalfunc = expectation_max_f_one, + initcond = '?8' +-- sortop = > +); +CREATE AGGREGATE sum(pip_eqn) +( + --We label this as a constraint type, since it can be applied on + --constrained columns... the corresponding constraints are pulled into the eqn. + CONSTRAINTTYPE, --HACKED_SQL_ONLY + sfunc = pip_eqn_compile_sum, + stype = pip_eqn, + initcond = '(0)' +); + +--------------- FUNCTIONS IN SQL --------------- +CREATE FUNCTION create_variable(varchar, anyelement) RETURNS pip_eqn AS $$ + SELECT create_variable(cast($1 as cstring), cast(nextval('pip_var_id') as integer), $2); + $$ LANGUAGE SQL VOLATILE STRICT; + +--------------- VARIABLE OPERATORS --------------- +CREATE OPERATOR + ( PROCEDURE=pip_eqn_sum, LEFTARG=pip_eqn , RIGHTARG=pip_eqn ); +CREATE OPERATOR + ( PROCEDURE=pip_eqn_sum, LEFTARG=integer , RIGHTARG=pip_eqn ); +CREATE OPERATOR + ( PROCEDURE=pip_eqn_sum, LEFTARG=pip_eqn , RIGHTARG=integer ); +CREATE OPERATOR + ( PROCEDURE=pip_eqn_sum, LEFTARG=double precision, RIGHTARG=pip_eqn ); +CREATE OPERATOR + ( PROCEDURE=pip_eqn_sum, LEFTARG=pip_eqn , RIGHTARG=double precision ); + +CREATE OPERATOR * ( PROCEDURE=pip_eqn_mul, LEFTARG=pip_eqn , RIGHTARG=pip_eqn ); +CREATE OPERATOR * ( PROCEDURE=pip_eqn_mul, LEFTARG=integer , RIGHTARG=pip_eqn ); +CREATE OPERATOR * ( PROCEDURE=pip_eqn_mul, LEFTARG=pip_eqn , RIGHTARG=integer ); +CREATE OPERATOR * ( PROCEDURE=pip_eqn_mul, LEFTARG=double precision, RIGHTARG=pip_eqn ); +CREATE OPERATOR * ( PROCEDURE=pip_eqn_mul, LEFTARG=pip_eqn , RIGHTARG=double precision ); + +CREATE OPERATOR - ( PROCEDURE=pip_eqn_sub, LEFTARG=pip_eqn , RIGHTARG=pip_eqn ); +CREATE OPERATOR - ( PROCEDURE=pip_eqn_sub, LEFTARG=integer , RIGHTARG=pip_eqn ); +CREATE OPERATOR - ( PROCEDURE=pip_eqn_sub, LEFTARG=pip_eqn , RIGHTARG=integer ); +CREATE OPERATOR - ( PROCEDURE=pip_eqn_sub, LEFTARG=double precision, RIGHTARG=pip_eqn ); +CREATE OPERATOR - ( PROCEDURE=pip_eqn_sub, LEFTARG=pip_eqn , RIGHTARG=double precision ); + +CREATE OPERATOR | ( PROCEDURE=pip_world_presence_union, LEFTARG=pip_world_presence, RIGHTARG=pip_world_presence ); + +CREATE OPERATOR > ( PROCEDURE=pip_atom_create_gt, LEFTARG=pip_eqn, RIGHTARG=pip_eqn ); +CREATE OPERATOR > ( PROCEDURE=pip_atom_create_gt, LEFTARG=double precision, RIGHTARG=pip_eqn ); +CREATE OPERATOR > ( PROCEDURE=pip_atom_create_gt, LEFTARG=pip_eqn, RIGHTARG=double precision ); +CREATE OPERATOR < ( PROCEDURE=pip_atom_create_lt, LEFTARG=pip_eqn, RIGHTARG=pip_eqn ); +CREATE OPERATOR < ( PROCEDURE=pip_atom_create_lt, LEFTARG=pip_eqn, RIGHTARG=double precision ); +CREATE OPERATOR < ( PROCEDURE=pip_atom_create_lt, LEFTARG=double precision, RIGHTARG=pip_eqn ); + +--------------- SEMANTIC SUGAR OPERATORS --------------- +CREATE OPERATOR << ( PROCEDURE=pip_expectation_make, RIGHTARG=pip_eqn ); +CREATE OPERATOR @ ( PROCEDURE=pip_expectation_fix, LEFTARG=pip_expectation, RIGHTARG=record ); +CREATE OPERATOR >> ( PROCEDURE=pip_expectation_expect, LEFTARG=pip_expectation ); diff --git a/pip_plugin/pip-uninstall.sql b/pip_plugin/pip-uninstall.sql new file mode 100644 index 0000000..f219fad --- /dev/null +++ b/pip_plugin/pip-uninstall.sql @@ -0,0 +1,132 @@ +DROP OPERATOR IF EXISTS + ( pip_eqn , pip_eqn ) CASCADE; +DROP OPERATOR IF EXISTS + ( integer , pip_eqn ) CASCADE; +DROP OPERATOR IF EXISTS + ( pip_eqn , integer ) CASCADE; +DROP OPERATOR IF EXISTS + ( double precision, pip_eqn ) CASCADE; +DROP OPERATOR IF EXISTS + ( pip_eqn , double precision ) CASCADE; +DROP OPERATOR IF EXISTS * ( pip_eqn , pip_eqn ) CASCADE; +DROP OPERATOR IF EXISTS * ( integer , pip_eqn ) CASCADE; +DROP OPERATOR IF EXISTS * ( pip_eqn , integer ) CASCADE; +DROP OPERATOR IF EXISTS * ( double precision, pip_eqn ) CASCADE; +DROP OPERATOR IF EXISTS * ( pip_eqn , double precision ) CASCADE; +DROP OPERATOR IF EXISTS - ( pip_eqn , pip_eqn ) CASCADE; +DROP OPERATOR IF EXISTS - ( integer , pip_eqn ) CASCADE; +DROP OPERATOR IF EXISTS - ( pip_eqn , integer ) CASCADE; +DROP OPERATOR IF EXISTS - ( double precision, pip_eqn ) CASCADE; +DROP OPERATOR IF EXISTS - ( pip_eqn , double precision ) CASCADE; +DROP OPERATOR IF EXISTS | ( pip_world_presence, pip_world_presence ) CASCADE; +DROP OPERATOR IF EXISTS > ( pip_eqn, pip_eqn ) CASCADE; +DROP OPERATOR IF EXISTS > ( double precision, pip_eqn ) CASCADE; +DROP OPERATOR IF EXISTS > ( pip_eqn, double precision ) CASCADE; +DROP OPERATOR IF EXISTS < ( pip_eqn, pip_eqn ) CASCADE; +DROP OPERATOR IF EXISTS < ( pip_eqn, double precision ) CASCADE; +DROP OPERATOR IF EXISTS < ( double precision, pip_eqn ) CASCADE; +DROP OPERATOR IF EXISTS << ( NONE,pip_eqn ) CASCADE; +DROP OPERATOR IF EXISTS @ ( pip_expectation, record ) CASCADE; +DROP OPERATOR IF EXISTS >> ( pip_expectation ,NONE) CASCADE; +DROP AGGREGATE IF EXISTS conf_naive (record,pip_sample_set) CASCADE; +DROP AGGREGATE IF EXISTS conf_sample (record,pip_sample_set) CASCADE; +DROP AGGREGATE IF EXISTS expectation_max_hist (pip_eqn, record) CASCADE; +DROP AGGREGATE IF EXISTS expectation_max (pip_eqn, record) CASCADE; +DROP AGGREGATE IF EXISTS expectation_max (pip_value_bundle) CASCADE; +DROP AGGREGATE IF EXISTS expectation_sum_hist (pip_eqn, record) CASCADE; +DROP AGGREGATE IF EXISTS expectation_sum (pip_eqn, record) CASCADE; +DROP AGGREGATE IF EXISTS expectation_sum (pip_eqn, record, integer) CASCADE; +DROP AGGREGATE IF EXISTS max(double precision, record) CASCADE; +DROP AGGREGATE IF EXISTS pip_world_presence_union (pip_world_presence) CASCADE; +DROP AGGREGATE IF EXISTS sum(pip_eqn) CASCADE; +DROP AGGREGATE IF EXISTS sum (pip_value_bundle) CASCADE; +DROP AGGREGATE IF EXISTS sum (pip_value_bundle,pip_world_presence) CASCADE; +DROP FUNCTION IF EXISTS conf_naive_g (pip_world_presence,record,pip_sample_set) CASCADE; +DROP FUNCTION IF EXISTS conf_one (record) CASCADE; +DROP FUNCTION IF EXISTS conf_sample_g (pip_conf_tally,record,pip_sample_set) CASCADE; +DROP FUNCTION IF EXISTS create_variable(cstring, integer, cstring) CASCADE; +DROP FUNCTION IF EXISTS create_variable(cstring, integer, record) CASCADE; +DROP FUNCTION IF EXISTS create_variable(varchar, anyelement) CASCADE; +DROP FUNCTION IF EXISTS expectation_max_f_one(pip_atomset) CASCADE; +DROP FUNCTION IF EXISTS expectation_max_g_one(pip_atomset, double precision, record) CASCADE; +DROP FUNCTION IF EXISTS expectation_max_g(pip_sample_set, pip_eqn, record) CASCADE; +DROP FUNCTION IF EXISTS expectation(pip_eqn, record, integer) CASCADE; +DROP FUNCTION IF EXISTS expectation(pip_eqn, record) CASCADE; +DROP FUNCTION IF EXISTS expectation_sum_g_one(double precision, pip_eqn, record, integer) CASCADE; +DROP FUNCTION IF EXISTS expectation_sum_g_one(double precision, pip_eqn, record) CASCADE; +DROP FUNCTION IF EXISTS expectation_sum_g(pip_sample_set, pip_eqn, record) CASCADE; +DROP FUNCTION IF EXISTS pip_atom_create_gt(double precision,pip_eqn) CASCADE; +DROP FUNCTION IF EXISTS pip_atom_create_gt(pip_eqn,double precision) CASCADE; +DROP FUNCTION IF EXISTS pip_atom_create_gt(pip_eqn,pip_eqn) CASCADE; +DROP FUNCTION IF EXISTS pip_atom_create_lt(double precision,pip_eqn) CASCADE; +DROP FUNCTION IF EXISTS pip_atom_create_lt(pip_eqn,double precision) CASCADE; +DROP FUNCTION IF EXISTS pip_atom_create_lt(pip_eqn,pip_eqn) CASCADE; +DROP FUNCTION IF EXISTS pip_atom_in(cstring) CASCADE; +DROP FUNCTION IF EXISTS pip_atom_out(pip_atom) CASCADE; +DROP FUNCTION IF EXISTS pip_atomset_in(cstring) CASCADE; +DROP FUNCTION IF EXISTS pip_atomset_out(pip_atomset) CASCADE; +DROP FUNCTION IF EXISTS pip_cdf_enabled(integer) CASCADE; +DROP FUNCTION IF EXISTS pip_conf_tally_in(cstring) CASCADE; +DROP FUNCTION IF EXISTS pip_conf_tally_out(pip_conf_tally) CASCADE; +DROP FUNCTION IF EXISTS pip_conf_tally_result(pip_conf_tally) CASCADE; +DROP FUNCTION IF EXISTS pip_eqn_compile_sum(pip_eqn,pip_eqn,record) CASCADE; +DROP FUNCTION IF EXISTS pip_eqn_compile_sum(pip_eqn,pip_eqn ) CASCADE; +DROP FUNCTION IF EXISTS pip_eqn_in(cstring) CASCADE; +DROP FUNCTION IF EXISTS pip_eqn_mul(double precision,pip_eqn) CASCADE; +DROP FUNCTION IF EXISTS pip_eqn_mul(integer,pip_eqn) CASCADE; +DROP FUNCTION IF EXISTS pip_eqn_mul(pip_eqn,double precision) CASCADE; +DROP FUNCTION IF EXISTS pip_eqn_mul(pip_eqn,integer) CASCADE; +DROP FUNCTION IF EXISTS pip_eqn_mul(pip_eqn,pip_eqn) CASCADE; +DROP FUNCTION IF EXISTS pip_eqn_neg(pip_eqn) CASCADE; +DROP FUNCTION IF EXISTS pip_eqn_out(pip_eqn) CASCADE; +DROP FUNCTION IF EXISTS pip_eqn_sub(double precision,pip_eqn) CASCADE; +DROP FUNCTION IF EXISTS pip_eqn_sub(integer,pip_eqn) CASCADE; +DROP FUNCTION IF EXISTS pip_eqn_sub(pip_eqn,double precision) CASCADE; +DROP FUNCTION IF EXISTS pip_eqn_sub(pip_eqn,integer) CASCADE; +DROP FUNCTION IF EXISTS pip_eqn_sub(pip_eqn,pip_eqn) CASCADE; +DROP FUNCTION IF EXISTS pip_eqn_sum(double precision,pip_eqn) CASCADE; +DROP FUNCTION IF EXISTS pip_eqn_sum(integer,pip_eqn) CASCADE; +DROP FUNCTION IF EXISTS pip_eqn_sum(pip_eqn,double precision) CASCADE; +DROP FUNCTION IF EXISTS pip_eqn_sum(pip_eqn,integer) CASCADE; +DROP FUNCTION IF EXISTS pip_eqn_sum(pip_eqn,pip_eqn) CASCADE; +DROP FUNCTION IF EXISTS pip_expectation_expect(pip_expectation) CASCADE; +DROP FUNCTION IF EXISTS pip_expectation_fix(pip_expectation,record) CASCADE; +DROP FUNCTION IF EXISTS pip_expectation_in(cstring) CASCADE; +DROP FUNCTION IF EXISTS pip_expectation_make(pip_eqn) CASCADE; +DROP FUNCTION IF EXISTS pip_expectation_out(pip_expectation) CASCADE; +DROP FUNCTION IF EXISTS pip_sample_set_expect(pip_sample_set) CASCADE; +DROP FUNCTION IF EXISTS pip_sample_set_explode(pip_sample_set) CASCADE; +DROP FUNCTION IF EXISTS pip_sample_set_generate(record,integer) CASCADE; +DROP FUNCTION IF EXISTS pip_sample_set_in(cstring) CASCADE; +DROP FUNCTION IF EXISTS pip_sample_set_out(pip_sample_set) CASCADE; +DROP FUNCTION IF EXISTS pip_value_bundle_add(pip_value_bundle,double precision) CASCADE; +DROP FUNCTION IF EXISTS pip_value_bundle_add(pip_value_bundle,pip_value_bundle,pip_world_presence) CASCADE; +DROP FUNCTION IF EXISTS pip_value_bundle_add(pip_value_bundle,pip_value_bundle) CASCADE; +DROP FUNCTION IF EXISTS pip_value_bundle_cmp(pip_world_presence,double precision,pip_value_bundle) CASCADE; +DROP FUNCTION IF EXISTS pip_value_bundle_cmp(pip_world_presence,integer,pip_value_bundle) CASCADE; +DROP FUNCTION IF EXISTS pip_value_bundle_cmp(pip_world_presence,pip_value_bundle,double precision) CASCADE; +DROP FUNCTION IF EXISTS pip_value_bundle_cmp(pip_world_presence,pip_value_bundle,integer) CASCADE; +DROP FUNCTION IF EXISTS pip_value_bundle_cmp(pip_world_presence,pip_value_bundle,pip_value_bundle) CASCADE; +DROP FUNCTION IF EXISTS pip_value_bundle_create(pip_eqn,integer) CASCADE; +DROP FUNCTION IF EXISTS pip_value_bundle_expect(pip_value_bundle,integer,integer,pip_world_presence) CASCADE; +DROP FUNCTION IF EXISTS pip_value_bundle_expect(pip_value_bundle,integer,integer) CASCADE; +DROP FUNCTION IF EXISTS pip_value_bundle_expect(pip_value_bundle,pip_world_presence) CASCADE; +DROP FUNCTION IF EXISTS pip_value_bundle_expect(pip_value_bundle) CASCADE; +DROP FUNCTION IF EXISTS pip_value_bundle_in(cstring) CASCADE; +DROP FUNCTION IF EXISTS pip_value_bundle_max(pip_value_bundle,pip_value_bundle) CASCADE; +DROP FUNCTION IF EXISTS pip_value_bundle_mul(pip_value_bundle,double precision) CASCADE; +DROP FUNCTION IF EXISTS pip_value_bundle_mul(pip_value_bundle,pip_value_bundle) CASCADE; +DROP FUNCTION IF EXISTS pip_value_bundle_out(pip_value_bundle) CASCADE; +DROP FUNCTION IF EXISTS pip_var_in(cstring) CASCADE; +DROP FUNCTION IF EXISTS pip_var_out(pip_var) CASCADE; +DROP FUNCTION IF EXISTS pip_world_presence_count(pip_world_presence) CASCADE; +DROP FUNCTION IF EXISTS pip_world_presence_create(integer) CASCADE; +DROP FUNCTION IF EXISTS pip_world_presence_in(cstring) CASCADE; +DROP FUNCTION IF EXISTS pip_world_presence_join(pip_world_presence,pip_world_presence) CASCADE; +DROP FUNCTION IF EXISTS pip_world_presence_out(pip_world_presence) CASCADE; +DROP FUNCTION IF EXISTS pip_world_presence_union(pip_world_presence,pip_world_presence) CASCADE; +DROP TYPE IF EXISTS pip_var CASCADE; +DROP TYPE IF EXISTS pip_atom CASCADE; +DROP TYPE IF EXISTS pip_sample_set CASCADE; +DROP TYPE IF EXISTS pip_conf_tally CASCADE; +DROP TYPE IF EXISTS pip_value_bundle CASCADE; +DROP TYPE IF EXISTS pip_world_presence CASCADE; +DROP TYPE IF EXISTS pip_eqn CASCADE; +DROP TYPE IF EXISTS pip_expectation CASCADE; +DROP TYPE IF EXISTS pip_atomset CASCADE; +DROP SEQUENCE IF EXISTS pip_var_id CASCADE; diff --git a/pip_plugin/pip-uninstall.sql.in b/pip_plugin/pip-uninstall.sql.in new file mode 100644 index 0000000..f219fad --- /dev/null +++ b/pip_plugin/pip-uninstall.sql.in @@ -0,0 +1,132 @@ +DROP OPERATOR IF EXISTS + ( pip_eqn , pip_eqn ) CASCADE; +DROP OPERATOR IF EXISTS + ( integer , pip_eqn ) CASCADE; +DROP OPERATOR IF EXISTS + ( pip_eqn , integer ) CASCADE; +DROP OPERATOR IF EXISTS + ( double precision, pip_eqn ) CASCADE; +DROP OPERATOR IF EXISTS + ( pip_eqn , double precision ) CASCADE; +DROP OPERATOR IF EXISTS * ( pip_eqn , pip_eqn ) CASCADE; +DROP OPERATOR IF EXISTS * ( integer , pip_eqn ) CASCADE; +DROP OPERATOR IF EXISTS * ( pip_eqn , integer ) CASCADE; +DROP OPERATOR IF EXISTS * ( double precision, pip_eqn ) CASCADE; +DROP OPERATOR IF EXISTS * ( pip_eqn , double precision ) CASCADE; +DROP OPERATOR IF EXISTS - ( pip_eqn , pip_eqn ) CASCADE; +DROP OPERATOR IF EXISTS - ( integer , pip_eqn ) CASCADE; +DROP OPERATOR IF EXISTS - ( pip_eqn , integer ) CASCADE; +DROP OPERATOR IF EXISTS - ( double precision, pip_eqn ) CASCADE; +DROP OPERATOR IF EXISTS - ( pip_eqn , double precision ) CASCADE; +DROP OPERATOR IF EXISTS | ( pip_world_presence, pip_world_presence ) CASCADE; +DROP OPERATOR IF EXISTS > ( pip_eqn, pip_eqn ) CASCADE; +DROP OPERATOR IF EXISTS > ( double precision, pip_eqn ) CASCADE; +DROP OPERATOR IF EXISTS > ( pip_eqn, double precision ) CASCADE; +DROP OPERATOR IF EXISTS < ( pip_eqn, pip_eqn ) CASCADE; +DROP OPERATOR IF EXISTS < ( pip_eqn, double precision ) CASCADE; +DROP OPERATOR IF EXISTS < ( double precision, pip_eqn ) CASCADE; +DROP OPERATOR IF EXISTS << ( NONE,pip_eqn ) CASCADE; +DROP OPERATOR IF EXISTS @ ( pip_expectation, record ) CASCADE; +DROP OPERATOR IF EXISTS >> ( pip_expectation ,NONE) CASCADE; +DROP AGGREGATE IF EXISTS conf_naive (record,pip_sample_set) CASCADE; +DROP AGGREGATE IF EXISTS conf_sample (record,pip_sample_set) CASCADE; +DROP AGGREGATE IF EXISTS expectation_max_hist (pip_eqn, record) CASCADE; +DROP AGGREGATE IF EXISTS expectation_max (pip_eqn, record) CASCADE; +DROP AGGREGATE IF EXISTS expectation_max (pip_value_bundle) CASCADE; +DROP AGGREGATE IF EXISTS expectation_sum_hist (pip_eqn, record) CASCADE; +DROP AGGREGATE IF EXISTS expectation_sum (pip_eqn, record) CASCADE; +DROP AGGREGATE IF EXISTS expectation_sum (pip_eqn, record, integer) CASCADE; +DROP AGGREGATE IF EXISTS max(double precision, record) CASCADE; +DROP AGGREGATE IF EXISTS pip_world_presence_union (pip_world_presence) CASCADE; +DROP AGGREGATE IF EXISTS sum(pip_eqn) CASCADE; +DROP AGGREGATE IF EXISTS sum (pip_value_bundle) CASCADE; +DROP AGGREGATE IF EXISTS sum (pip_value_bundle,pip_world_presence) CASCADE; +DROP FUNCTION IF EXISTS conf_naive_g (pip_world_presence,record,pip_sample_set) CASCADE; +DROP FUNCTION IF EXISTS conf_one (record) CASCADE; +DROP FUNCTION IF EXISTS conf_sample_g (pip_conf_tally,record,pip_sample_set) CASCADE; +DROP FUNCTION IF EXISTS create_variable(cstring, integer, cstring) CASCADE; +DROP FUNCTION IF EXISTS create_variable(cstring, integer, record) CASCADE; +DROP FUNCTION IF EXISTS create_variable(varchar, anyelement) CASCADE; +DROP FUNCTION IF EXISTS expectation_max_f_one(pip_atomset) CASCADE; +DROP FUNCTION IF EXISTS expectation_max_g_one(pip_atomset, double precision, record) CASCADE; +DROP FUNCTION IF EXISTS expectation_max_g(pip_sample_set, pip_eqn, record) CASCADE; +DROP FUNCTION IF EXISTS expectation(pip_eqn, record, integer) CASCADE; +DROP FUNCTION IF EXISTS expectation(pip_eqn, record) CASCADE; +DROP FUNCTION IF EXISTS expectation_sum_g_one(double precision, pip_eqn, record, integer) CASCADE; +DROP FUNCTION IF EXISTS expectation_sum_g_one(double precision, pip_eqn, record) CASCADE; +DROP FUNCTION IF EXISTS expectation_sum_g(pip_sample_set, pip_eqn, record) CASCADE; +DROP FUNCTION IF EXISTS pip_atom_create_gt(double precision,pip_eqn) CASCADE; +DROP FUNCTION IF EXISTS pip_atom_create_gt(pip_eqn,double precision) CASCADE; +DROP FUNCTION IF EXISTS pip_atom_create_gt(pip_eqn,pip_eqn) CASCADE; +DROP FUNCTION IF EXISTS pip_atom_create_lt(double precision,pip_eqn) CASCADE; +DROP FUNCTION IF EXISTS pip_atom_create_lt(pip_eqn,double precision) CASCADE; +DROP FUNCTION IF EXISTS pip_atom_create_lt(pip_eqn,pip_eqn) CASCADE; +DROP FUNCTION IF EXISTS pip_atom_in(cstring) CASCADE; +DROP FUNCTION IF EXISTS pip_atom_out(pip_atom) CASCADE; +DROP FUNCTION IF EXISTS pip_atomset_in(cstring) CASCADE; +DROP FUNCTION IF EXISTS pip_atomset_out(pip_atomset) CASCADE; +DROP FUNCTION IF EXISTS pip_cdf_enabled(integer) CASCADE; +DROP FUNCTION IF EXISTS pip_conf_tally_in(cstring) CASCADE; +DROP FUNCTION IF EXISTS pip_conf_tally_out(pip_conf_tally) CASCADE; +DROP FUNCTION IF EXISTS pip_conf_tally_result(pip_conf_tally) CASCADE; +DROP FUNCTION IF EXISTS pip_eqn_compile_sum(pip_eqn,pip_eqn,record) CASCADE; +DROP FUNCTION IF EXISTS pip_eqn_compile_sum(pip_eqn,pip_eqn ) CASCADE; +DROP FUNCTION IF EXISTS pip_eqn_in(cstring) CASCADE; +DROP FUNCTION IF EXISTS pip_eqn_mul(double precision,pip_eqn) CASCADE; +DROP FUNCTION IF EXISTS pip_eqn_mul(integer,pip_eqn) CASCADE; +DROP FUNCTION IF EXISTS pip_eqn_mul(pip_eqn,double precision) CASCADE; +DROP FUNCTION IF EXISTS pip_eqn_mul(pip_eqn,integer) CASCADE; +DROP FUNCTION IF EXISTS pip_eqn_mul(pip_eqn,pip_eqn) CASCADE; +DROP FUNCTION IF EXISTS pip_eqn_neg(pip_eqn) CASCADE; +DROP FUNCTION IF EXISTS pip_eqn_out(pip_eqn) CASCADE; +DROP FUNCTION IF EXISTS pip_eqn_sub(double precision,pip_eqn) CASCADE; +DROP FUNCTION IF EXISTS pip_eqn_sub(integer,pip_eqn) CASCADE; +DROP FUNCTION IF EXISTS pip_eqn_sub(pip_eqn,double precision) CASCADE; +DROP FUNCTION IF EXISTS pip_eqn_sub(pip_eqn,integer) CASCADE; +DROP FUNCTION IF EXISTS pip_eqn_sub(pip_eqn,pip_eqn) CASCADE; +DROP FUNCTION IF EXISTS pip_eqn_sum(double precision,pip_eqn) CASCADE; +DROP FUNCTION IF EXISTS pip_eqn_sum(integer,pip_eqn) CASCADE; +DROP FUNCTION IF EXISTS pip_eqn_sum(pip_eqn,double precision) CASCADE; +DROP FUNCTION IF EXISTS pip_eqn_sum(pip_eqn,integer) CASCADE; +DROP FUNCTION IF EXISTS pip_eqn_sum(pip_eqn,pip_eqn) CASCADE; +DROP FUNCTION IF EXISTS pip_expectation_expect(pip_expectation) CASCADE; +DROP FUNCTION IF EXISTS pip_expectation_fix(pip_expectation,record) CASCADE; +DROP FUNCTION IF EXISTS pip_expectation_in(cstring) CASCADE; +DROP FUNCTION IF EXISTS pip_expectation_make(pip_eqn) CASCADE; +DROP FUNCTION IF EXISTS pip_expectation_out(pip_expectation) CASCADE; +DROP FUNCTION IF EXISTS pip_sample_set_expect(pip_sample_set) CASCADE; +DROP FUNCTION IF EXISTS pip_sample_set_explode(pip_sample_set) CASCADE; +DROP FUNCTION IF EXISTS pip_sample_set_generate(record,integer) CASCADE; +DROP FUNCTION IF EXISTS pip_sample_set_in(cstring) CASCADE; +DROP FUNCTION IF EXISTS pip_sample_set_out(pip_sample_set) CASCADE; +DROP FUNCTION IF EXISTS pip_value_bundle_add(pip_value_bundle,double precision) CASCADE; +DROP FUNCTION IF EXISTS pip_value_bundle_add(pip_value_bundle,pip_value_bundle,pip_world_presence) CASCADE; +DROP FUNCTION IF EXISTS pip_value_bundle_add(pip_value_bundle,pip_value_bundle) CASCADE; +DROP FUNCTION IF EXISTS pip_value_bundle_cmp(pip_world_presence,double precision,pip_value_bundle) CASCADE; +DROP FUNCTION IF EXISTS pip_value_bundle_cmp(pip_world_presence,integer,pip_value_bundle) CASCADE; +DROP FUNCTION IF EXISTS pip_value_bundle_cmp(pip_world_presence,pip_value_bundle,double precision) CASCADE; +DROP FUNCTION IF EXISTS pip_value_bundle_cmp(pip_world_presence,pip_value_bundle,integer) CASCADE; +DROP FUNCTION IF EXISTS pip_value_bundle_cmp(pip_world_presence,pip_value_bundle,pip_value_bundle) CASCADE; +DROP FUNCTION IF EXISTS pip_value_bundle_create(pip_eqn,integer) CASCADE; +DROP FUNCTION IF EXISTS pip_value_bundle_expect(pip_value_bundle,integer,integer,pip_world_presence) CASCADE; +DROP FUNCTION IF EXISTS pip_value_bundle_expect(pip_value_bundle,integer,integer) CASCADE; +DROP FUNCTION IF EXISTS pip_value_bundle_expect(pip_value_bundle,pip_world_presence) CASCADE; +DROP FUNCTION IF EXISTS pip_value_bundle_expect(pip_value_bundle) CASCADE; +DROP FUNCTION IF EXISTS pip_value_bundle_in(cstring) CASCADE; +DROP FUNCTION IF EXISTS pip_value_bundle_max(pip_value_bundle,pip_value_bundle) CASCADE; +DROP FUNCTION IF EXISTS pip_value_bundle_mul(pip_value_bundle,double precision) CASCADE; +DROP FUNCTION IF EXISTS pip_value_bundle_mul(pip_value_bundle,pip_value_bundle) CASCADE; +DROP FUNCTION IF EXISTS pip_value_bundle_out(pip_value_bundle) CASCADE; +DROP FUNCTION IF EXISTS pip_var_in(cstring) CASCADE; +DROP FUNCTION IF EXISTS pip_var_out(pip_var) CASCADE; +DROP FUNCTION IF EXISTS pip_world_presence_count(pip_world_presence) CASCADE; +DROP FUNCTION IF EXISTS pip_world_presence_create(integer) CASCADE; +DROP FUNCTION IF EXISTS pip_world_presence_in(cstring) CASCADE; +DROP FUNCTION IF EXISTS pip_world_presence_join(pip_world_presence,pip_world_presence) CASCADE; +DROP FUNCTION IF EXISTS pip_world_presence_out(pip_world_presence) CASCADE; +DROP FUNCTION IF EXISTS pip_world_presence_union(pip_world_presence,pip_world_presence) CASCADE; +DROP TYPE IF EXISTS pip_var CASCADE; +DROP TYPE IF EXISTS pip_atom CASCADE; +DROP TYPE IF EXISTS pip_sample_set CASCADE; +DROP TYPE IF EXISTS pip_conf_tally CASCADE; +DROP TYPE IF EXISTS pip_value_bundle CASCADE; +DROP TYPE IF EXISTS pip_world_presence CASCADE; +DROP TYPE IF EXISTS pip_eqn CASCADE; +DROP TYPE IF EXISTS pip_expectation CASCADE; +DROP TYPE IF EXISTS pip_atomset CASCADE; +DROP SEQUENCE IF EXISTS pip_var_id CASCADE; diff --git a/pip_plugin/pip.sql b/pip_plugin/pip.sql new file mode 100644 index 0000000..0068bce --- /dev/null +++ b/pip_plugin/pip.sql @@ -0,0 +1,308 @@ +CREATE SEQUENCE pip_var_id; + +--------------- VARIABLE PREDECLARATIONS --------------- +CREATE TYPE pip_var; +CREATE TYPE pip_atom; +CREATE TYPE pip_sample_set; +CREATE TYPE pip_conf_tally; +CREATE TYPE pip_value_bundle; +CREATE TYPE pip_world_presence; +CREATE TYPE pip_eqn; +CREATE TYPE pip_expectation; +CREATE TYPE pip_atomset; + +--------------- pip_var FUNCTIONS --------------- +CREATE FUNCTION pip_var_in(cstring) RETURNS pip_var AS 'MODULE_PATHNAME','pip_var_in' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_var_out(pip_var) RETURNS cstring AS 'MODULE_PATHNAME','pip_var_out' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION create_variable(cstring, integer, cstring) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_var_create_str' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION create_variable(cstring, integer, record) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_var_create_row' LANGUAGE C VOLATILE STRICT; + +--------------- pip_eqn FUNCTIONS --------------- +CREATE FUNCTION pip_eqn_in(cstring) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_in' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_out(pip_eqn) RETURNS cstring AS 'MODULE_PATHNAME','pip_eqn_out' LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION expectation(pip_eqn, record) RETURNS double precision AS 'MODULE_PATHNAME','pip_expectation' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION expectation(pip_eqn, record, integer) RETURNS double precision AS 'MODULE_PATHNAME','pip_expectation' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION expectation_max_g(pip_sample_set, pip_eqn, record) RETURNS pip_sample_set AS 'MODULE_PATHNAME','pip_expectation_max_g' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION expectation_max_g_one(pip_atomset, double precision, record) RETURNS pip_atomset AS 'MODULE_PATHNAME','pip_expectation_max_g_one' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION expectation_max_f_one(pip_atomset) RETURNS double precision AS 'MODULE_PATHNAME','pip_expectation_max_f_one' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION expectation_sum_g(pip_sample_set, pip_eqn, record) RETURNS pip_sample_set AS 'MODULE_PATHNAME','pip_expectation_sum_g' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION expectation_sum_g_one(double precision, pip_eqn, record) RETURNS double precision AS 'MODULE_PATHNAME','pip_expectation_sum_g_one' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION expectation_sum_g_one(double precision, pip_eqn, record, integer) RETURNS double precision AS 'MODULE_PATHNAME','pip_expectation_sum_g_one' LANGUAGE C VOLATILE STRICT; + +CREATE FUNCTION pip_eqn_sum(pip_eqn,pip_eqn) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_sum_ee' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_sum(pip_eqn,integer) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_sum_ei' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_sum(integer,pip_eqn) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_sum_ie' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_sum(pip_eqn,double precision) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_sum_ef' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_sum(double precision,pip_eqn) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_sum_fe' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_compile_sum(pip_eqn,pip_eqn,record) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_compile_sum' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_compile_sum(pip_eqn,pip_eqn ) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_compile_sum' LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION pip_eqn_mul(pip_eqn,pip_eqn) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_mul_ee' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_mul(pip_eqn,integer) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_mul_ei' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_mul(integer,pip_eqn) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_mul_ie' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_mul(pip_eqn,double precision) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_mul_ef' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_mul(double precision,pip_eqn) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_mul_fe' LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION pip_eqn_neg(pip_eqn) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_neg' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_sub(pip_eqn,pip_eqn) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_sub_ee' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_sub(pip_eqn,integer) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_sub_ei' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_sub(integer,pip_eqn) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_sub_ie' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_sub(pip_eqn,double precision) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_sub_ef' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_eqn_sub(double precision,pip_eqn) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_sub_fe' LANGUAGE C IMMUTABLE STRICT; + +--------------- pip_expectation FUNCTIONS --------------- +-- Expectation is a semantic sugar hack to cheat the parser... +-- Consequently the IO operations here are identical to those for pip_eqn +CREATE FUNCTION pip_expectation_in(cstring) RETURNS pip_expectation AS 'MODULE_PATHNAME','pip_exp_in' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_expectation_out(pip_expectation) RETURNS cstring AS 'MODULE_PATHNAME','pip_exp_out' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_expectation_make(pip_eqn) RETURNS pip_expectation AS 'MODULE_PATHNAME','pip_exp_make' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_expectation_fix(pip_expectation,record) RETURNS pip_expectation AS 'MODULE_PATHNAME','pip_exp_fix' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_expectation_expect(pip_expectation) RETURNS double precision AS 'MODULE_PATHNAME','pip_exp_expect' LANGUAGE C IMMUTABLE STRICT; + +--------------- pip_atom FUNCTIONS --------------- +CREATE FUNCTION pip_atom_in(cstring) RETURNS pip_atom AS 'MODULE_PATHNAME','pip_atom_in' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_atom_out(pip_atom) RETURNS cstring AS 'MODULE_PATHNAME','pip_atom_out' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_atom_create_gt(pip_eqn,pip_eqn) RETURNS pip_atom AS 'MODULE_PATHNAME','pip_atom_create_gt_ee' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION pip_atom_create_gt(pip_eqn,double precision) RETURNS pip_atom AS 'MODULE_PATHNAME','pip_atom_create_gt_ef' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION pip_atom_create_gt(double precision,pip_eqn) RETURNS pip_atom AS 'MODULE_PATHNAME','pip_atom_create_gt_fe' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION pip_atom_create_lt(pip_eqn,pip_eqn) RETURNS pip_atom AS 'MODULE_PATHNAME','pip_atom_create_lt_ee' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION pip_atom_create_lt(pip_eqn,double precision) RETURNS pip_atom AS 'MODULE_PATHNAME','pip_atom_create_lt_ef' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION pip_atom_create_lt(double precision,pip_eqn) RETURNS pip_atom AS 'MODULE_PATHNAME','pip_atom_create_lt_fe' LANGUAGE C VOLATILE STRICT; + +--------------- pip_atomset FUNCTIONS --------------- +CREATE FUNCTION pip_atomset_in(cstring) RETURNS pip_atomset AS 'MODULE_PATHNAME','pip_atomset_in' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_atomset_out(pip_atomset) RETURNS cstring AS 'MODULE_PATHNAME','pip_atomset_out' LANGUAGE C IMMUTABLE STRICT; + +--------------- pip_sample_set FUNCTIONS --------------- +CREATE FUNCTION pip_sample_set_in(cstring) RETURNS pip_sample_set AS 'MODULE_PATHNAME','pip_sample_set_in' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_sample_set_out(pip_sample_set) RETURNS cstring AS 'MODULE_PATHNAME','pip_sample_set_out' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_sample_set_generate(record,integer) RETURNS pip_sample_set AS 'MODULE_PATHNAME','pip_sample_set_generate' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION pip_sample_set_explode(pip_sample_set) RETURNS SETOF double precision AS 'MODULE_PATHNAME','pip_sample_set_explode' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_sample_set_expect(pip_sample_set) RETURNS double precision AS 'MODULE_PATHNAME','pip_sample_set_expect' LANGUAGE C IMMUTABLE STRICT; + +--------------- INTEGRATION FUNCTIONS --------------- +CREATE FUNCTION conf_one (record) RETURNS double precision AS 'MODULE_PATHNAME','conf_one' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION conf_sample_g (pip_conf_tally,record,pip_sample_set) RETURNS pip_conf_tally AS 'MODULE_PATHNAME','pip_atom_conf_sample_g' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION conf_naive_g (pip_world_presence,record,pip_sample_set) RETURNS pip_world_presence AS 'MODULE_PATHNAME','pip_atom_sample_set_presence' LANGUAGE C IMMUTABLE STRICT; + +--------------- pip_conf_tally FUNCTIONS --------------- +CREATE FUNCTION pip_conf_tally_in(cstring) RETURNS pip_conf_tally AS 'MODULE_PATHNAME','pip_conf_tally_in' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_conf_tally_out(pip_conf_tally) RETURNS cstring AS 'MODULE_PATHNAME','pip_conf_tally_out' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_conf_tally_result(pip_conf_tally) RETURNS double precision AS 'MODULE_PATHNAME','pip_conf_tally_result' LANGUAGE C IMMUTABLE STRICT; + +--------------- pip_world_presence FUNCTIONS --------------- +CREATE FUNCTION pip_world_presence_in(cstring) RETURNS pip_world_presence AS 'MODULE_PATHNAME','pip_world_presence_in' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_world_presence_out(pip_world_presence) RETURNS cstring AS 'MODULE_PATHNAME','pip_world_presence_out' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_world_presence_create(integer) RETURNS pip_world_presence AS 'MODULE_PATHNAME','pip_world_presence_create' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION pip_world_presence_count(pip_world_presence) RETURNS double precision AS 'MODULE_PATHNAME','pip_world_presence_count' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_world_presence_union(pip_world_presence,pip_world_presence) RETURNS pip_world_presence AS 'MODULE_PATHNAME','pip_world_presence_union' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_world_presence_join(pip_world_presence,pip_world_presence) RETURNS pip_world_presence AS 'MODULE_PATHNAME','pip_world_presence_join' LANGUAGE C IMMUTABLE STRICT; + +--------------- pip_value_bundle FUNCTIONS --------------- +CREATE FUNCTION pip_value_bundle_in(cstring) RETURNS pip_value_bundle AS 'MODULE_PATHNAME','pip_value_bundle_in' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_out(pip_value_bundle) RETURNS cstring AS 'MODULE_PATHNAME','pip_value_bundle_out' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_create(pip_eqn,integer) RETURNS pip_value_bundle AS 'MODULE_PATHNAME','pip_value_bundle_create' LANGUAGE C VOLATILE STRICT; +CREATE FUNCTION pip_value_bundle_cmp(pip_world_presence,integer,pip_value_bundle) RETURNS pip_world_presence AS 'MODULE_PATHNAME','pip_value_bundle_cmp_iv' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_cmp(pip_world_presence,double precision,pip_value_bundle) RETURNS pip_world_presence AS 'MODULE_PATHNAME','pip_value_bundle_cmp_fv' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_cmp(pip_world_presence,pip_value_bundle,integer) RETURNS pip_world_presence AS 'MODULE_PATHNAME','pip_value_bundle_cmp_vi' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_cmp(pip_world_presence,pip_value_bundle,double precision) RETURNS pip_world_presence AS 'MODULE_PATHNAME','pip_value_bundle_cmp_vf' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_cmp(pip_world_presence,pip_value_bundle,pip_value_bundle) RETURNS pip_world_presence AS 'MODULE_PATHNAME','pip_value_bundle_cmp_vv' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_add(pip_value_bundle,double precision) RETURNS pip_value_bundle AS 'MODULE_PATHNAME','pip_value_bundle_add_vf' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_add(pip_value_bundle,pip_value_bundle) RETURNS pip_value_bundle AS 'MODULE_PATHNAME','pip_value_bundle_add_vv' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_add(pip_value_bundle,pip_value_bundle,pip_world_presence) RETURNS pip_value_bundle AS 'MODULE_PATHNAME','pip_value_bundle_add_vv' LANGUAGE C IMMUTABLE; +CREATE FUNCTION pip_value_bundle_mul(pip_value_bundle,double precision) RETURNS pip_value_bundle AS 'MODULE_PATHNAME','pip_value_bundle_mul_vf' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_mul(pip_value_bundle,pip_value_bundle) RETURNS pip_value_bundle AS 'MODULE_PATHNAME','pip_value_bundle_mul_vv' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_max(pip_value_bundle,pip_value_bundle) RETURNS pip_value_bundle AS 'MODULE_PATHNAME','pip_value_bundle_max' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_expect(pip_value_bundle) RETURNS double precision AS 'MODULE_PATHNAME','pip_value_bundle_expect' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_expect(pip_value_bundle,pip_world_presence) RETURNS double precision AS 'MODULE_PATHNAME','pip_value_bundle_expect' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_expect(pip_value_bundle,integer,integer) RETURNS double precision AS 'MODULE_PATHNAME','pip_value_bundle_expect' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_value_bundle_expect(pip_value_bundle,integer,integer,pip_world_presence) RETURNS double precision AS 'MODULE_PATHNAME','pip_value_bundle_expect' LANGUAGE C IMMUTABLE STRICT; + +--------------- DEBUG/TEST FUNCTIONS --------------- +CREATE FUNCTION pip_cdf_enabled(integer) RETURNS integer AS 'MODULE_PATHNAME','pip_set_cdf_sampling_enabled' LANGUAGE C IMMUTABLE STRICT; + +--------------- VARIABLE DEFINITIONS --------------- +CREATE TYPE pip_var ( + INPUT = pip_var_in, + OUTPUT = pip_var_out, + STORAGE = external +); +CREATE TYPE pip_atom ( + INPUT = pip_atom_in, + OUTPUT = pip_atom_out, + CONSTRAINTTYPE, --HACKED_SQL_ONLY + STORAGE = external +); +CREATE TYPE pip_sample_set ( + INPUT = pip_sample_set_in, + OUTPUT = pip_sample_set_out, + STORAGE = external +); +CREATE TYPE pip_conf_tally ( + INPUT = pip_conf_tally_in, + OUTPUT = pip_conf_tally_out, + STORAGE = external +); +CREATE TYPE pip_value_bundle ( + INPUT = pip_value_bundle_in, + OUTPUT = pip_value_bundle_out, + STORAGE = external +); +CREATE TYPE pip_world_presence ( + INPUT = pip_world_presence_in, + OUTPUT = pip_world_presence_out, + STORAGE = external +); +CREATE TYPE pip_eqn ( + INPUT = pip_eqn_in, + OUTPUT = pip_eqn_out, + STORAGE = external +); +CREATE TYPE pip_expectation ( + INPUT = pip_expectation_in, + OUTPUT = pip_expectation_out, + STORAGE = external +); +CREATE TYPE pip_atomset ( + INPUT = pip_atomset_in, + OUTPUT = pip_atomset_out, + STORAGE = external +); + +--------------- AGGREGATE FUNCTIONS --------------- +CREATE AGGREGATE expectation_max (pip_eqn, record) +( + CONSTRAINTTYPE, --HACKED_SQL_ONLY + sfunc = expectation_max_g, + stype = pip_sample_set, + finalfunc = pip_sample_set_expect, + initcond = '?1000/1' +); +CREATE AGGREGATE expectation_max_hist (pip_eqn, record) +( + CONSTRAINTTYPE, --HACKED_SQL_ONLY + sfunc = expectation_max_g, + stype = pip_sample_set, + initcond = '?1000/1' +); + +CREATE AGGREGATE expectation_sum (pip_eqn, record, integer) +( + CONSTRAINTTYPE, --HACKED_SQL_ONLY + sfunc = expectation_sum_g_one, + stype = double precision, + initcond = '0.0' +); +CREATE AGGREGATE expectation_sum (pip_eqn, record) +( + CONSTRAINTTYPE, --HACKED_SQL_ONLY + sfunc = expectation_sum_g_one, + stype = double precision, + initcond = '0.0' +); +CREATE AGGREGATE expectation_sum_hist (pip_eqn, record) +( + CONSTRAINTTYPE, --HACKED_SQL_ONLY + sfunc = expectation_sum_g, + stype = pip_sample_set, + initcond = '?1000/1' +); + +CREATE AGGREGATE conf_sample (record,pip_sample_set) +( + CONSTRAINTTYPE, --HACKED_SQL_ONLY + sfunc = conf_sample_g, + stype = pip_conf_tally, + finalfunc = pip_conf_tally_result, + initcond = '0:0' +); + +CREATE AGGREGATE pip_world_presence_union (pip_world_presence) +( + CONSTRAINTTYPE, --HACKED_SQL_ONLY + sfunc = pip_world_presence_union, + stype = pip_world_presence +); + +CREATE AGGREGATE conf_naive (record,pip_sample_set) +( + CONSTRAINTTYPE, --HACKED_SQL_ONLY + sfunc = conf_naive_g, + stype = pip_world_presence, + finalfunc = pip_world_presence_count, + initcond = '?0' +); +CREATE AGGREGATE sum (pip_value_bundle) +( + sfunc = pip_value_bundle_add, + stype = pip_value_bundle +); +CREATE AGGREGATE sum (pip_value_bundle,pip_world_presence) +( + sfunc = pip_value_bundle_add, + stype = pip_value_bundle +); +CREATE AGGREGATE expectation_max (pip_value_bundle) +( + CONSTRAINTTYPE, --HACKED_SQL_ONLY + sfunc = pip_value_bundle_max, + stype = pip_value_bundle, + finalfunc = pip_value_bundle_expect +); +CREATE AGGREGATE max(double precision, record) +( + CONSTRAINTTYPE, --HACKED_SQL_ONLY + sfunc = expectation_max_g_one, + stype = pip_atomset, + finalfunc = expectation_max_f_one, + initcond = '?8' +-- sortop = > +); +CREATE AGGREGATE sum(pip_eqn) +( + --We label this as a constraint type, since it can be applied on + --constrained columns... the corresponding constraints are pulled into the eqn. + CONSTRAINTTYPE, --HACKED_SQL_ONLY + sfunc = pip_eqn_compile_sum, + stype = pip_eqn, + initcond = '(0)' +); + +--------------- FUNCTIONS IN SQL --------------- +CREATE FUNCTION create_variable(varchar, anyelement) RETURNS pip_eqn AS $$ + SELECT create_variable(cast($1 as cstring), cast(nextval('pip_var_id') as integer), $2); + $$ LANGUAGE SQL VOLATILE STRICT; + +--------------- VARIABLE OPERATORS --------------- +CREATE OPERATOR + ( PROCEDURE=pip_eqn_sum, LEFTARG=pip_eqn , RIGHTARG=pip_eqn ); +CREATE OPERATOR + ( PROCEDURE=pip_eqn_sum, LEFTARG=integer , RIGHTARG=pip_eqn ); +CREATE OPERATOR + ( PROCEDURE=pip_eqn_sum, LEFTARG=pip_eqn , RIGHTARG=integer ); +CREATE OPERATOR + ( PROCEDURE=pip_eqn_sum, LEFTARG=double precision, RIGHTARG=pip_eqn ); +CREATE OPERATOR + ( PROCEDURE=pip_eqn_sum, LEFTARG=pip_eqn , RIGHTARG=double precision ); + +CREATE OPERATOR * ( PROCEDURE=pip_eqn_mul, LEFTARG=pip_eqn , RIGHTARG=pip_eqn ); +CREATE OPERATOR * ( PROCEDURE=pip_eqn_mul, LEFTARG=integer , RIGHTARG=pip_eqn ); +CREATE OPERATOR * ( PROCEDURE=pip_eqn_mul, LEFTARG=pip_eqn , RIGHTARG=integer ); +CREATE OPERATOR * ( PROCEDURE=pip_eqn_mul, LEFTARG=double precision, RIGHTARG=pip_eqn ); +CREATE OPERATOR * ( PROCEDURE=pip_eqn_mul, LEFTARG=pip_eqn , RIGHTARG=double precision ); + +CREATE OPERATOR - ( PROCEDURE=pip_eqn_sub, LEFTARG=pip_eqn , RIGHTARG=pip_eqn ); +CREATE OPERATOR - ( PROCEDURE=pip_eqn_sub, LEFTARG=integer , RIGHTARG=pip_eqn ); +CREATE OPERATOR - ( PROCEDURE=pip_eqn_sub, LEFTARG=pip_eqn , RIGHTARG=integer ); +CREATE OPERATOR - ( PROCEDURE=pip_eqn_sub, LEFTARG=double precision, RIGHTARG=pip_eqn ); +CREATE OPERATOR - ( PROCEDURE=pip_eqn_sub, LEFTARG=pip_eqn , RIGHTARG=double precision ); + +CREATE OPERATOR | ( PROCEDURE=pip_world_presence_union, LEFTARG=pip_world_presence, RIGHTARG=pip_world_presence ); + +CREATE OPERATOR > ( PROCEDURE=pip_atom_create_gt, LEFTARG=pip_eqn, RIGHTARG=pip_eqn ); +CREATE OPERATOR > ( PROCEDURE=pip_atom_create_gt, LEFTARG=double precision, RIGHTARG=pip_eqn ); +CREATE OPERATOR > ( PROCEDURE=pip_atom_create_gt, LEFTARG=pip_eqn, RIGHTARG=double precision ); +CREATE OPERATOR < ( PROCEDURE=pip_atom_create_lt, LEFTARG=pip_eqn, RIGHTARG=pip_eqn ); +CREATE OPERATOR < ( PROCEDURE=pip_atom_create_lt, LEFTARG=pip_eqn, RIGHTARG=double precision ); +CREATE OPERATOR < ( PROCEDURE=pip_atom_create_lt, LEFTARG=double precision, RIGHTARG=pip_eqn ); + +--------------- SEMANTIC SUGAR OPERATORS --------------- +CREATE OPERATOR << ( PROCEDURE=pip_expectation_make, RIGHTARG=pip_eqn ); +CREATE OPERATOR @ ( PROCEDURE=pip_expectation_fix, LEFTARG=pip_expectation, RIGHTARG=record ); +CREATE OPERATOR >> ( PROCEDURE=pip_expectation_expect, LEFTARG=pip_expectation ); diff --git a/pip_plugin/src/funcs.c b/pip_plugin/src/funcs.c index 68da4cf..d469e51 100644 --- a/pip_plugin/src/funcs.c +++ b/pip_plugin/src/funcs.c @@ -91,6 +91,7 @@ PG_FUNCTION_INFO_V1(pip_world_presence_out); PG_FUNCTION_INFO_V1(pip_world_presence_create); PG_FUNCTION_INFO_V1(pip_world_presence_count); PG_FUNCTION_INFO_V1(pip_world_presence_union); +PG_FUNCTION_INFO_V1(pip_world_presence_join); #include "funcs/integration.c" #include "funcs/pip_atom.c" #include "funcs/pip_atomset.c" diff --git a/pip_plugin/src/funcs/pip_world_presence.c b/pip_plugin/src/funcs/pip_world_presence.c index 50e4ed9..ff170ad 100644 --- a/pip_plugin/src/funcs/pip_world_presence.c +++ b/pip_plugin/src/funcs/pip_world_presence.c @@ -113,3 +113,16 @@ Datum pip_world_presence_union (PG_FUNCTION_ARGS) // elog(NOTICE, "UNION COMPLETE"); PG_RETURN_POINTER(wp1); } +Datum pip_world_presence_join (PG_FUNCTION_ARGS) +{ + pip_world_presence *wp1 = (pip_world_presence *)PG_GETARG_BYTEA_P_COPY(0); + pip_world_presence *wp2 = (pip_world_presence *)PG_GETARG_BYTEA_P(1); + int i; + + // elog(NOTICE, "UNION: %d(%d),%d(%d)", wp1->worldcount, VARSIZE(wp1), wp2->worldcount, VARSIZE(wp2)); + for(i = 0; i < (MIN(wp1->worldcount, wp2->worldcount)+7) / 8; i++){ + wp1->data[i] &= wp2->data[i]; + } + // elog(NOTICE, "UNION COMPLETE"); + PG_RETURN_POINTER(wp1); +} diff --git a/pip_plugin/src/include/funcs.h b/pip_plugin/src/include/funcs.h index 9d55a34..4c81095 100644 --- a/pip_plugin/src/include/funcs.h +++ b/pip_plugin/src/include/funcs.h @@ -83,4 +83,6 @@ Datum pip_world_presence_out (PG_FUNCTION_ARGS) ; Datum pip_world_presence_create(PG_FUNCTION_ARGS) ; Datum pip_world_presence_count(PG_FUNCTION_ARGS) ; Datum pip_world_presence_union (PG_FUNCTION_ARGS) ; +Datum pip_world_presence_join (PG_FUNCTION_ARGS); + #endif diff --git a/pip_plugin/src/pip.source b/pip_plugin/src/pip.source index ee08508..0068bce 100644 --- a/pip_plugin/src/pip.source +++ b/pip_plugin/src/pip.source @@ -97,6 +97,7 @@ CREATE FUNCTION pip_world_presence_out(pip_world_presence) CREATE FUNCTION pip_world_presence_create(integer) RETURNS pip_world_presence AS 'MODULE_PATHNAME','pip_world_presence_create' LANGUAGE C VOLATILE STRICT; CREATE FUNCTION pip_world_presence_count(pip_world_presence) RETURNS double precision AS 'MODULE_PATHNAME','pip_world_presence_count' LANGUAGE C IMMUTABLE STRICT; CREATE FUNCTION pip_world_presence_union(pip_world_presence,pip_world_presence) RETURNS pip_world_presence AS 'MODULE_PATHNAME','pip_world_presence_union' LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION pip_world_presence_join(pip_world_presence,pip_world_presence) RETURNS pip_world_presence AS 'MODULE_PATHNAME','pip_world_presence_join' LANGUAGE C IMMUTABLE STRICT; --------------- pip_value_bundle FUNCTIONS --------------- CREATE FUNCTION pip_value_bundle_in(cstring) RETURNS pip_value_bundle AS 'MODULE_PATHNAME','pip_value_bundle_in' LANGUAGE C IMMUTABLE STRICT;