309 lines
21 KiB
MySQL
309 lines
21 KiB
MySQL
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 );
|