You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hawq.apache.org by rl...@apache.org on 2018/05/18 09:51:29 UTC
[1/9] incubator-hawq git commit: HAWQ-1612. Implement vectorized
aggregate functions, such as avg/sum/count.
Repository: incubator-hawq
Updated Branches:
refs/heads/master 25ed0ae26 -> ce2814d4e
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/ce2814d4/src/test/feature/vexecutor/sql/create_type.sql
----------------------------------------------------------------------
diff --git a/src/test/feature/vexecutor/sql/create_type.sql b/src/test/feature/vexecutor/sql/create_type.sql
index c7f9c4f..e7f37f8 100644
--- a/src/test/feature/vexecutor/sql/create_type.sql
+++ b/src/test/feature/vexecutor/sql/create_type.sql
@@ -1,12 +1,4 @@
--- drop types first
-drop type vint2 cascade;
-drop type vint4 cascade;
-drop type vint8 cascade;
-drop type vfloat8 cascade;
-drop type vfloat4 cascade;
-drop type vbool cascade;
-drop type vdateadt cascade;
-drop type vtimeadt cascade;
+
-- create vectorized types
@@ -44,18 +36,11 @@ CREATE FUNCTION vboolin(cstring) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMU
CREATE FUNCTION vboolout(vbool) RETURNS cstring AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
CREATE TYPE vbool ( INPUT = vboolin, OUTPUT = vboolout, element = bool, storage=external );
-CREATE TYPE vtimeadt;
-CREATE FUNCTION vtimeadtin(cstring) RETURNS vtimeadt as 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE FUNCTION vtimeadtout(vtimeadt) RETURNS cstring AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE TYPE vtimeadt ( input = vtimeadtin, output = vtimeadtout, element = time , storage=external);
-
-
CREATE TYPE vdateadt;
CREATE FUNCTION vdateadtin(cstring) RETURNS vdateadt as 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION vdateadtout(vdateadt) RETURNS cstring AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
CREATE TYPE vdateadt ( INPUT = vdateadtin, OUTPUT = vdateadtout, element = date , storage=external);
-
-- create operators for the vectorized types
CREATE FUNCTION vint2vint2gt(vint2, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
@@ -926,6 +911,51 @@ CREATE OPERATOR * ( leftarg = vfloat8, rightarg = float8, procedure = vfloat8flo
CREATE FUNCTION vfloat8float8div(vfloat8, float8) RETURNS vfloat8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
CREATE OPERATOR / ( leftarg = vfloat8, rightarg = float8, procedure = vfloat8float8div, commutator = * );
+CREATE FUNCTION int2vint2pl(int2, vint2) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR + ( leftarg = int2, rightarg = vint2, procedure = int2vint2pl, commutator = - );
+CREATE FUNCTION int2vint2mi(int2, vint2) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR - ( leftarg = int2, rightarg = vint2, procedure = int2vint2mi, commutator = + );
+CREATE FUNCTION int2vint2mul(int2, vint2) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR * ( leftarg = int2, rightarg = vint2, procedure = int2vint2mul, commutator = / );
+CREATE FUNCTION int2vint2div(int2, vint2) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR / ( leftarg = int2, rightarg = vint2, procedure = int2vint2div, commutator = * );
+
+CREATE FUNCTION int4vint4pl(int4, vint4) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR + ( leftarg = int4, rightarg = vint4, procedure = int4vint4pl, commutator = - );
+CREATE FUNCTION int4vint4mi(int4, vint4) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR - ( leftarg = int4, rightarg = vint4, procedure = int4vint4mi, commutator = + );
+CREATE FUNCTION int4vint4mul(int4, vint4) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR * ( leftarg = int4, rightarg = vint4, procedure = int4vint4mul, commutator = / );
+CREATE FUNCTION int4vint4div(int4, vint4) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR / ( leftarg = int4, rightarg = vint4, procedure = int4vint4div, commutator = * );
+
+CREATE FUNCTION int8vint8pl(int8, vint8) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR + ( leftarg = int8, rightarg = vint8, procedure = int8vint8pl, commutator = - );
+CREATE FUNCTION int8vint8mi(int8, vint8) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR - ( leftarg = int8, rightarg = vint8, procedure = int8vint8mi, commutator = + );
+CREATE FUNCTION int8vint8mul(int8, vint8) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR * ( leftarg = int8, rightarg = vint8, procedure = int8vint8mul, commutator = / );
+CREATE FUNCTION int8vint8div(int8, vint8) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR / ( leftarg = int8, rightarg = vint8, procedure = int8vint8div, commutator = * );
+
+CREATE FUNCTION float4vfloat4pl(float4, vfloat4) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR + ( leftarg = float4, rightarg = vfloat4, procedure = float4vfloat4pl, commutator = - );
+CREATE FUNCTION float4vfloat4mi(float4, vfloat4) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR - ( leftarg = float4, rightarg = vfloat4, procedure = float4vfloat4mi, commutator = + );
+CREATE FUNCTION float4vfloat4mul(float4, vfloat4) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR * ( leftarg = float4, rightarg = vfloat4, procedure = float4vfloat4mul, commutator = / );
+CREATE FUNCTION float4vfloat4div(float4, vfloat4) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR / ( leftarg = float4, rightarg = vfloat4, procedure = float4vfloat4div, commutator = * );
+
+
+CREATE FUNCTION float8vfloat8pl(float8, vfloat8) RETURNS vfloat8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR + ( leftarg = float8, rightarg = vfloat8, procedure = float8vfloat8pl, commutator = - );
+CREATE FUNCTION float8vfloat8mi(float8, vfloat8) RETURNS vfloat8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR - ( leftarg = float8, rightarg = vfloat8, procedure = float8vfloat8mi, commutator = + );
+CREATE FUNCTION float8vfloat8mul(float8, vfloat8) RETURNS vfloat8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR * ( leftarg = float8, rightarg = vfloat8, procedure = float8vfloat8mul, commutator = / );
+CREATE FUNCTION float8vfloat8div(float8, vfloat8) RETURNS vfloat8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR / ( leftarg = float8, rightarg = vfloat8, procedure = float8vfloat8div, commutator = * );
CREATE FUNCTION vdateadt_eq(vdateadt, vdateadt) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
CREATE OPERATOR = ( leftarg = vdateadt, rightarg = vdateadt, procedure = vdateadt_eq, commutator = = );
@@ -947,17 +977,112 @@ CREATE FUNCTION vdateadt_mii(vdateadt, vint4) RETURNS vdateadt AS 'vexecutor.so'
CREATE OPERATOR - ( leftarg = vdateadt, rightarg = vint4, procedure = vdateadt_mii, commutator = - );
+CREATE FUNCTION vdateadt_eq_dateadt(vdateadt, date) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vdateadt, rightarg = date, procedure = vdateadt_eq_dateadt, commutator = = );
+CREATE FUNCTION vdateadt_ne_dateadt(vdateadt, date) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vdateadt, rightarg = date, procedure = vdateadt_ne_dateadt, commutator = <> );
+CREATE FUNCTION vdateadt_lt_dateadt(vdateadt, date ) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vdateadt, rightarg = date, procedure = vdateadt_lt_dateadt, commutator = < );
+CREATE FUNCTION vdateadt_le_dateadt(vdateadt, date) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vdateadt, rightarg = date, procedure = vdateadt_le_dateadt, commutator = <= );
+CREATE FUNCTION vdateadt_gt_dateadt(vdateadt, date) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vdateadt, rightarg = date, procedure = vdateadt_gt_dateadt, commutator = > );
+CREATE FUNCTION vdateadt_ge_dateadt(vdateadt, date) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vdateadt, rightarg = date, procedure = vdateadt_ge_dateadt, commutator = >= );
+CREATE FUNCTION vdateadt_mi_dateadt(vdateadt, date) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR - ( leftarg = vdateadt, rightarg = date, procedure = vdateadt_mi_dateadt, commutator = - );
+CREATE FUNCTION vdateadt_pli_int4(vdateadt, int4) RETURNS vdateadt AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR + ( leftarg = vdateadt, rightarg = int4, procedure = vdateadt_pli_int4, commutator = + );
+CREATE FUNCTION vdateadt_mii_int4(vdateadt, int4) RETURNS vdateadt AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR - ( leftarg = vdateadt, rightarg = int4, procedure = vdateadt_mii_int4, commutator = - );
+
+
+--create sum aggregate functions
+
+CREATE FUNCTION vint2_accum(int8, vint2) returns int8 as 'vexecutor.so' language c immutable;
+CREATE AGGREGATE sum(vint2) (
+ sfunc = vint2_accum,
+ stype = int8);
+
+CREATE FUNCTION vint4_accum(int8, vint4) returns int8 as 'vexecutor.so' language c immutable;
+CREATE AGGREGATE sum(vint4) (
+ sfunc = vint4_accum,
+ stype = int8);
+
+CREATE FUNCTION vint8_accum(numeric, vint8) returns numeric as 'vexecutor.so' language c immutable;
+CREATE AGGREGATE sum(vint8) (
+ sfunc = vint8_accum,
+ stype = numeric);
+
+CREATE FUNCTION vfloat4_accum(float4, vfloat4) returns float4 as 'vexecutor.so' language c immutable;
+CREATE AGGREGATE sum(vfloat4) (
+ sfunc = vfloat4_accum,
+ stype = float4);
+
+CREATE FUNCTION vfloat8_accum(float8, vfloat8) returns float8 as 'vexecutor.so' language c immutable;
+CREATE AGGREGATE sum(vfloat8) (
+ sfunc = vfloat8_accum,
+ stype = float8);
+
+
+
+--create avg aggregate functions
+
+CREATE FUNCTION vint2_avg_accum(bytea, vint2) returns bytea as 'vexecutor.so' language c immutable;
+CREATE AGGREGATE avg(vint2) (
+ sfunc = vint2_avg_accum,
+ stype = bytea);
+
+CREATE FUNCTION vint4_avg_accum(bytea, vint4) returns bytea as 'vexecutor.so' language c immutable;
+CREATE AGGREGATE avg(vint4) (
+ sfunc = vint4_avg_accum,
+ stype = bytea);
+
+CREATE FUNCTION vint8_avg_accum(bytea, vint8) returns bytea as 'vexecutor.so' language c immutable;
+CREATE AGGREGATE avg(vint8) (
+ sfunc = vint8_avg_accum,
+ stype = bytea);
+
+CREATE FUNCTION vfloat4_avg_accum(bytea, vfloat4) returns bytea as 'vexecutor.so' language c immutable;
+CREATE AGGREGATE avg(vfloat4) (
+ sfunc = vfloat4_avg_accum,
+ stype = bytea);
+
+CREATE FUNCTION vfloat8_avg_accum(bytea, vfloat8) returns bytea as 'vexecutor.so' language c immutable;
+CREATE AGGREGATE avg(vfloat8) (
+ sfunc = vfloat8_avg_accum,
+ stype = bytea);
+
+
+--create count aggregate functions
+
+CREATE FUNCTION vint2_inc(int8, vint2) returns int8 as 'vexecutor.so' language c immutable;
+create AGGREGATE count(vint2) (
+ sfunc = vint2_inc,
+ stype = int8);
+
+CREATE FUNCTION vint4_inc(int8, vint4) returns int8 as 'vexecutor.so' language c immutable;
+create AGGREGATE count(vint4) (
+ sfunc = vint4_inc,
+ stype = int8);
-CREATE FUNCTION vtimeadt_eq(vtimeadt, vtimeadt) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vtimeadt, rightarg = vtimeadt, procedure = vtimeadt_eq, commutator = = );
-CREATE FUNCTION vtimeadt_ne(vtimeadt, vtimeadt) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vtimeadt, rightarg = vtimeadt, procedure = vtimeadt_ne, commutator = <> );
-CREATE FUNCTION vtimeadt_lt(vtimeadt, vtimeadt) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vtimeadt, rightarg = vtimeadt, procedure = vtimeadt_lt, commutator = < );
-CREATE FUNCTION vtimeadt_le(vtimeadt, vtimeadt) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vtimeadt, rightarg = vtimeadt, procedure = vtimeadt_le, commutator = <= );
-CREATE FUNCTION vtimeadt_gt(vtimeadt, vtimeadt) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vtimeadt, rightarg = vtimeadt, procedure = vtimeadt_gt, commutator = > );
-CREATE FUNCTION vtimeadt_ge(vtimeadt, vtimeadt) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vtimeadt, rightarg = vtimeadt, procedure = vtimeadt_ge, commutator = >= );
+CREATE FUNCTION vint8_inc(int8, vint8) returns int8 as 'vexecutor.so' language c immutable;
+create AGGREGATE count(vint8) (
+ sfunc = vint8_inc,
+ stype = int8);
+
+CREATE FUNCTION vfloat4_inc(int8, vfloat4) returns int8 as 'vexecutor.so' language c immutable;
+create AGGREGATE count(vfloat4) (
+ sfunc = vfloat4_inc,
+ stype = int8);
+
+CREATE FUNCTION vfloat8_inc(int8, vfloat8) returns int8 as 'vexecutor.so' language c immutable;
+create AGGREGATE count(vfloat8) (
+ sfunc = vfloat8_inc,
+ stype = int8);
+--change the name to veccount, urgly...we will use this function to replace this count(*) functions in vcheck.c
+CREATE FUNCTION vec_inc_any(int8) returns int8 as 'vexecutor.so' language c immutable;
+create AGGREGATE veccount(*) (
+ sfunc = vec_inc_any,
+ stype = int8);
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/ce2814d4/src/test/feature/vexecutor/sql/drop_type.sql
----------------------------------------------------------------------
diff --git a/src/test/feature/vexecutor/sql/drop_type.sql b/src/test/feature/vexecutor/sql/drop_type.sql
index 6d311ed..1cee20f 100644
--- a/src/test/feature/vexecutor/sql/drop_type.sql
+++ b/src/test/feature/vexecutor/sql/drop_type.sql
@@ -1,7 +1,49 @@
--- drop types cascade
+--drop agg functions
+--drop the previous funcitons
+DROP AGGREGATE IF EXISTS sum(vint2);
+DROP AGGREGATE IF EXISTS sum(vint4);
+DROP AGGREGATE IF EXISTS sum(vint8);
+DROP AGGREGATE IF EXISTS sum(vfloat4);
+DROP AGGREGATE IF EXISTS sum(vfloat8);
+
+DROP AGGREGATE IF EXISTS avg(vint2);
+DROP AGGREGATE IF EXISTS avg(vint4);
+DROP AGGREGATE IF EXISTS avg(vint8);
+DROP AGGREGATE IF EXISTS avg(vfloat4);
+DROP AGGREGATE IF EXISTS avg(vfloat8);
+
+DROP AGGREGATE IF EXISTS count(vint2);
+DROP AGGREGATE IF EXISTS count(vint4);
+DROP AGGREGATE IF EXISTS count(vint8);
+DROP AGGREGATE IF EXISTS count(vfloat4);
+DROP AGGREGATE IF EXISTS count(vfloat8);
+
+DROP AGGREGATE IF EXISTS veccount(*);
+
+DROP FUNCTION IF EXISTS vint2_accum(int8, vint2);
+DROP FUNCTION IF EXISTS vint4_accum(int8, vint4);
+DROP FUNCTION IF EXISTS vint8_accum(numeric, vint8);
+DROP FUNCTION IF EXISTS vfloat4_accum(float4, vfloat4);
+DROP FUNCTION IF EXISTS vfloat8_accum(float8, vfloat8);
+
+DROP FUNCTION IF EXISTS vint2_avg_accum(bytea, vint2);
+DROP FUNCTION IF EXISTS vint4_avg_accum(bytea, vint4);
+DROP FUNCTION IF EXISTS vint8_avg_accum(bytea, vint8);
+DROP FUNCTION IF EXISTS vfloat4_avg_accum(bytea, vfloat4);
+DROP FUNCTION IF EXISTS vfloat8_avg_accum(bytea, vfloat8);
+
+DROP FUNCTION IF EXISTS vint2_inc(int8, vint2);
+DROP FUNCTION IF EXISTS vint4_inc(int8, vint4);
+DROP FUNCTION IF EXISTS vint8_inc(int8, vint8);
+DROP FUNCTION IF EXISTS vfloat4_inc(int8, vfloat4);
+DROP FUNCTION IF EXISTS vfloat8_inc(int8, vfloat8);
+
+DROP FUNCTION IF EXISTS vec_inc_any(int8);
+
drop type vint2 cascade;
drop type vint4 cascade;
drop type vint8 cascade;
drop type vfloat8 cascade;
drop type vfloat4 cascade;
drop type vbool cascade;
+drop type vdateadt cascade;
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/ce2814d4/src/test/feature/vexecutor/sql/vagg.sql
----------------------------------------------------------------------
diff --git a/src/test/feature/vexecutor/sql/vagg.sql b/src/test/feature/vexecutor/sql/vagg.sql
new file mode 100644
index 0000000..3895081
--- /dev/null
+++ b/src/test/feature/vexecutor/sql/vagg.sql
@@ -0,0 +1,301 @@
+
+
+
+select avg(a), count(b), sum(c), count(*) from test_int2;
+select avg(a), count(b), sum(c), count(*) from test_int4;
+select avg(a), count(b), sum(c), count(*) from test_int8;
+select avg(a), count(b), sum(c), count(*) from test_float4;
+select avg(a), count(b), sum(c), count(*) from test_float8;
+
+
+select avg(a), count(b), sum(c), count(*) from test_int2 where a > 65536 and b > 0;
+select avg(a), count(b), sum(c), count(*) from test_int4 where a > 65536 and b > 0;
+select avg(a), count(b), sum(c), count(*) from test_int8 where a > 65536 and b > 0;
+select avg(a), count(b), sum(c), count(*) from test_float4 where a > 65536 and b > 0;
+select avg(a), count(b), sum(c), count(*) from test_float8 where a > 65536 and b > 0;
+
+select avg(a), count(b), sum(c), count(*) from test_int2 where a > 5120 and b > 0;
+select avg(a), count(b), sum(c), count(*) from test_int4 where a > 5120 and b > 0;
+select avg(a), count(b), sum(c), count(*) from test_int8 where a > 5120 and b > 0;
+select avg(a), count(b), sum(c), count(*) from test_float4 where a > 5120 and b > 0;
+select avg(a), count(b), sum(c), count(*) from test_float8 where a > 5120 and b > 0;
+
+
+
+select avg(a), count(b), sum(c), count(*) from test_int2 where a > 5120 and b > 0;
+select avg(a), count(b), sum(c), count(*) from test_int4 where a > 5120 and b > 0;
+select avg(a), count(b), sum(c), count(*) from test_int8 where a > 5120 and b > 0;
+select avg(a), count(b), sum(c), count(*) from test_float4 where a > 5120 and b > 0;
+select avg(a), count(b), sum(c), count(*) from test_float8 where a > 5120 and b > 0;
+
+
+select avg(a), count(b), sum(c), count(*) from test_int2;
+select avg(a), count(b), sum(c), count(*) from test_int4;
+select avg(a), count(b), sum(c), count(*) from test_int8;
+select avg(a), count(b), sum(c), count(*) from test_float4;
+select avg(a), count(b), sum(c), count(*) from test_float8;
+
+
+select avg(a) from test_int2;
+select avg(a) from test_int4;
+select avg(a) from test_int8;
+select avg(a) from test_float4;
+select avg(a) from test_float8;
+
+
+select avg(a) from test_int2 where a > 5120 and b > 0;
+select avg(a) from test_int4 where a > 5120 and b > 0;
+select avg(a) from test_int8 where a > 5120 and b > 0;
+select avg(a) from test_float4 where a > 5120 and b > 0;
+select avg(a) from test_float8 where a > 5120 and b > 0;
+
+select sum(a) from test_int2;
+select sum(a) from test_int4;
+select sum(a) from test_int8;
+select sum(a) from test_float4;
+select sum(a) from test_float8;
+
+
+select sum(a) from test_int2 where a > 5120 and b > 0;
+select sum(a) from test_int4 where a > 5120 and b > 0;
+select sum(a) from test_int8 where a > 5120 and b > 0;
+select sum(a) from test_float4 where a > 5120 and b > 0;
+select sum(a) from test_float8 where a > 5120 and b > 0;
+
+
+select count(a) from test_int2;
+select count(a) from test_int4;
+select count(a) from test_int8;
+select count(a) from test_float4;
+select count(a) from test_float8;
+
+
+select count(a) from test_int2 where a > 5120 and b > 0;
+select count(a) from test_int4 where a > 5120 and b > 0;
+select count(a) from test_int8 where a > 5120 and b > 0;
+select count(a) from test_float4 where a > 5120 and b > 0;
+select count(a) from test_float8 where a > 5120 and b > 0;
+
+select count(*) from test_int2;
+select count(*) from test_int4;
+select count(*) from test_int8;
+select count(*) from test_float4;
+select count(*) from test_float8;
+
+
+select count(*) from test_int2 where a > 5120 and b > 0;
+select count(*) from test_int4 where a > 5120 and b > 0;
+select count(*) from test_int8 where a > 5120 and b > 0;
+select count(*) from test_float4 where a > 5120 and b > 0;
+select count(*) from test_float8 where a > 5120 and b > 0;
+
+
+
+--group by a;
+select avg(a), count(b), sum(c), count(*) from test_int2 where a > 5120 and b > 0 group by a order by a;
+select avg(a), count(b), sum(c), count(*) from test_int4 where a > 5120 and b > 0 group by a order by a;
+select avg(a), count(b), sum(c), count(*) from test_int8 where a > 5120 and b > 0 group by a order by a;
+select avg(a), count(b), sum(c), count(*) from test_float4 where a > 5120 and b > 0 group by a order by a;
+select avg(a), count(b), sum(c), count(*) from test_float8 where a > 5120 and b > 0 group by a order by a;
+
+
+select avg(a), count(b), sum(c), count(*) from test_int2 group by a order by a;
+select avg(a), count(b), sum(c), count(*) from test_int4 group by a order by a;
+select avg(a), count(b), sum(c), count(*) from test_int8 group by a order by a;
+select avg(a), count(b), sum(c), count(*) from test_float4 group by a order by a;
+select avg(a), count(b), sum(c), count(*) from test_float8 group by a order by a;
+
+
+select avg(a) from test_int2 group by a order by a;
+select avg(a) from test_int4 group by a order by a;
+select avg(a) from test_int8 group by a order by a;
+select avg(a) from test_float4 group by a order by a;
+select avg(a) from test_float8 group by a order by a;
+
+
+select avg(a) from test_int2 where a > 5120 and b > 0 group by a order by a;
+select avg(a) from test_int4 where a > 5120 and b > 0 group by a order by a;
+select avg(a) from test_int8 where a > 5120 and b > 0 group by a order by a;
+select avg(a) from test_float4 where a > 5120 and b > 0 group by a order by a;
+select avg(a) from test_float8 where a > 5120 and b > 0 group by a order by a;
+
+select sum(a) from test_int2 group by a order by a;
+select sum(a) from test_int4 group by a order by a;
+select sum(a) from test_int8 group by a order by a;
+select sum(a) from test_float4 group by a order by a;
+select sum(a) from test_float8 group by a order by a;
+
+
+select sum(a) from test_int2 where a > 5120 and b > 0 group by a order by a;
+select sum(a) from test_int4 where a > 5120 and b > 0 group by a order by a;
+select sum(a) from test_int8 where a > 5120 and b > 0 group by a order by a;
+select sum(a) from test_float4 where a > 5120 and b > 0 group by a order by a;
+select sum(a) from test_float8 where a > 5120 and b > 0 group by a order by a;
+
+
+select count(a) from test_int2 group by a;
+select count(a) from test_int4 group by a;
+select count(a) from test_int8 group by a;
+select count(a) from test_float4 group by a;
+select count(a) from test_float8 group by a;
+
+
+select count(a) from test_int2 where a > 5120 and b > 0 group by a;
+select count(a) from test_int4 where a > 5120 and b > 0 group by a;
+select count(a) from test_int8 where a > 5120 and b > 0 group by a;
+select count(a) from test_float4 where a > 5120 and b > 0 group by a;
+select count(a) from test_float8 where a > 5120 and b > 0 group by a;
+
+select count(*) from test_int2 group by a;
+select count(*) from test_int4 group by a;
+select count(*) from test_int8 group by a;
+select count(*) from test_float4 group by a;
+select count(*) from test_float8 group by a;
+
+
+select count(*) from test_int2 where a > 5120 and b > 0 group by a;
+select count(*) from test_int4 where a > 5120 and b > 0 group by a;
+select count(*) from test_int8 where a > 5120 and b > 0 group by a;
+select count(*) from test_float4 where a > 5120 and b > 0 group by a;
+select count(*) from test_float8 where a > 5120 and b > 0 group by a;
+
+
+--group by b;
+select avg(a), count(b), sum(c), count(*) from test_int2 where a > 5120 and b > 0 group by b;
+select avg(a), count(b), sum(c), count(*) from test_int4 where a > 5120 and b > 0 group by b;
+select avg(a), count(b), sum(c), count(*) from test_int8 where a > 5120 and b > 0 group by b;
+select avg(a), count(b), sum(c), count(*) from test_float4 where a > 5120 and b > 0 group by b;
+select avg(a), count(b), sum(c), count(*) from test_float8 where a > 5120 and b > 0 group by b;
+
+
+select avg(a), count(b), sum(c), count(*) from test_int2 group by b;
+select avg(a), count(b), sum(c), count(*) from test_int4 group by b;
+select avg(a), count(b), sum(c), count(*) from test_int8 group by b;
+select avg(a), count(b), sum(c), count(*) from test_float4 group by b;
+select avg(a), count(b), sum(c), count(*) from test_float8 group by b;
+
+
+select avg(a) from test_int2 group by b;
+select avg(a) from test_int4 group by b;
+select avg(a) from test_int8 group by b;
+select avg(a) from test_float4 group by b;
+select avg(a) from test_float8 group by b;
+
+
+select avg(a) from test_int2 where a > 5120 and b > 0 group by b;
+select avg(a) from test_int4 where a > 5120 and b > 0 group by b;
+select avg(a) from test_int8 where a > 5120 and b > 0 group by b;
+select avg(a) from test_float4 where a > 5120 and b > 0 group by b;
+select avg(a) from test_float8 where a > 5120 and b > 0 group by b;
+
+select sum(a) from test_int2 group by b;
+select sum(a) from test_int4 group by b;
+select sum(a) from test_int8 group by b;
+select sum(a) from test_float4 group by b;
+select sum(a) from test_float8 group by b;
+
+
+select sum(a) from test_int2 where a > 5120 and b > 0 group by b;
+select sum(a) from test_int4 where a > 5120 and b > 0 group by b;
+select sum(a) from test_int8 where a > 5120 and b > 0 group by b;
+select sum(a) from test_float4 where a > 5120 and b > 0 group by b;
+select sum(a) from test_float8 where a > 5120 and b > 0 group by b;
+
+
+select count(a) from test_int2 group by b;
+select count(a) from test_int4 group by b;
+select count(a) from test_int8 group by b;
+select count(a) from test_float4 group by b;
+select count(a) from test_float8 group by b;
+
+
+select count(a) from test_int2 where a > 5120 and b > 0 group by b;
+select count(a) from test_int4 where a > 5120 and b > 0 group by b;
+select count(a) from test_int8 where a > 5120 and b > 0 group by b;
+select count(a) from test_float4 where a > 5120 and b > 0 group by b;
+select count(a) from test_float8 where a > 5120 and b > 0 group by b;
+
+select count(*) from test_int2 group by b;
+select count(*) from test_int4 group by b;
+select count(*) from test_int8 group by b;
+select count(*) from test_float4 group by b;
+select count(*) from test_float8 group by b;
+
+
+select count(*) from test_int2 where a > 5120 and b > 0 group by b;
+select count(*) from test_int4 where a > 5120 and b > 0 group by b;
+select count(*) from test_int8 where a > 5120 and b > 0 group by b;
+select count(*) from test_float4 where a > 5120 and b > 0 group by b;
+select count(*) from test_float8 where a > 5120 and b > 0 group by b;
+
+
+--group by b,c;
+select avg(a), count(b), sum(c), count(*) from test_int2 where a > 5120 and b > 0 group by b,c;
+select avg(a), count(b), sum(c), count(*) from test_int4 where a > 5120 and b > 0 group by b,c;
+select avg(a), count(b), sum(c), count(*) from test_int8 where a > 5120 and b > 0 group by b,c;
+select avg(a), count(b), sum(c), count(*) from test_float4 where a > 5120 and b > 0 group by b,c;
+select avg(a), count(b), sum(c), count(*) from test_float8 where a > 5120 and b > 0 group by b,c;
+
+
+select avg(a), count(b), sum(c), count(*) from test_int2 group by b,c;
+select avg(a), count(b), sum(c), count(*) from test_int4 group by b,c;
+select avg(a), count(b), sum(c), count(*) from test_int8 group by b,c;
+select avg(a), count(b), sum(c), count(*) from test_float4 group by b,c;
+select avg(a), count(b), sum(c), count(*) from test_float8 group by b,c;
+
+
+select avg(a) from test_int2 group by b,c;
+select avg(a) from test_int4 group by b,c;
+select avg(a) from test_int8 group by b,c;
+select avg(a) from test_float4 group by b,c;
+select avg(a) from test_float8 group by b,c;
+
+
+select avg(a) from test_int2 where a > 5120 and b > 0 group by b,c;
+select avg(a) from test_int4 where a > 5120 and b > 0 group by b,c;
+select avg(a) from test_int8 where a > 5120 and b > 0 group by b,c;
+select avg(a) from test_float4 where a > 5120 and b > 0 group by b,c;
+select avg(a) from test_float8 where a > 5120 and b > 0 group by b,c;
+
+select sum(a) from test_int2 group by b,c;
+select sum(a) from test_int4 group by b,c;
+select sum(a) from test_int8 group by b,c;
+select sum(a) from test_float4 group by b,c;
+select sum(a) from test_float8 group by b,c;
+
+
+select sum(a) from test_int2 where a > 5120 and b > 0 group by b,c;
+select sum(a) from test_int4 where a > 5120 and b > 0 group by b,c;
+select sum(a) from test_int8 where a > 5120 and b > 0 group by b,c;
+select sum(a) from test_float4 where a > 5120 and b > 0 group by b,c;
+select sum(a) from test_float8 where a > 5120 and b > 0 group by b,c;
+
+
+select count(a) from test_int2 group by b,c;
+select count(a) from test_int4 group by b,c;
+select count(a) from test_int8 group by b,c;
+select count(a) from test_float4 group by b,c;
+select count(a) from test_float8 group by b,c;
+
+
+select count(a) from test_int2 where a > 5120 and b > 0 group by b,c;
+select count(a) from test_int4 where a > 5120 and b > 0 group by b,c;
+select count(a) from test_int8 where a > 5120 and b > 0 group by b,c;
+select count(a) from test_float4 where a > 5120 and b > 0 group by b,c;
+select count(a) from test_float8 where a > 5120 and b > 0 group by b,c;
+
+select count(*) from test_int2 group by b,c;
+select count(*) from test_int4 group by b,c;
+select count(*) from test_int8 group by b,c;
+select count(*) from test_float4 group by b,c;
+select count(*) from test_float8 group by b,c;
+
+
+select count(*) from test_int2 where a > 5120 and b > 0 group by b,c;
+select count(*) from test_int4 where a > 5120 and b > 0 group by b,c;
+select count(*) from test_int8 where a > 5120 and b > 0 group by b,c;
+select count(*) from test_float4 where a > 5120 and b > 0 group by b,c;
+select count(*) from test_float8 where a > 5120 and b > 0 group by b,c;
+
+
+
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/ce2814d4/src/test/feature/vexecutor/test_vexecutor.cpp
----------------------------------------------------------------------
diff --git a/src/test/feature/vexecutor/test_vexecutor.cpp b/src/test/feature/vexecutor/test_vexecutor.cpp
index de85da2..6cd226b 100644
--- a/src/test/feature/vexecutor/test_vexecutor.cpp
+++ b/src/test/feature/vexecutor/test_vexecutor.cpp
@@ -29,41 +29,19 @@ class TestVexecutor : public ::testing::Test
~TestVexecutor(){};
};
-//#define TEST_F_FILE(TestName, basePath, testcase) \
-//TEST_F(TestName, testcase) \
-//{ \
-// hawq::test::SQLUtility util; \
-// string SqlFile(basePath); \
-// string AnsFile(basePath); \
-// SqlFile += "/sql/" #testcase ".sql"; \
-// AnsFile += "/ans/" #testcase ".ans"; \
-// util.execSQLFile(SqlFile, AnsFile); \
-//}
-//
-//#define TEST_F_FILE_TYPE(testcase) TEST_F_FILE(TestVexecutor, "vexecutor", testcase)
-//TEST_F_FILE_TYPE(create_type)
-//TEST_F_FILE_TYPE(vadt)
-//TEST_F_FILE_TYPE(drop_type)
TEST_F(TestVexecutor, vadt)
{
// preprocess source files to get sql/ans files
hawq::test::SQLUtility util;
- util.execute("drop type vint2 cascade", false);
- util.execute("drop type vint4 cascade", false);
- util.execute("drop type vint8 cascade", false);
- util.execute("drop type vfloat4 cascade", false);
- util.execute("drop type vfloat8 cascade", false);
- util.execute("drop type vbool cascade", false);
-
- // run sql file to get ans file and then diff it with out file
util.execSQLFile("vexecutor/sql/create_type.sql",
- "vexecutor/ans/create_type.ans");
+ "vexecutor/ans/create_type_vadt.ans");
util.execSQLFile("vexecutor/sql/vadt.sql",
"vexecutor/ans/vadt.ans");
+ // run sql file to get ans file and then diff it with out file
util.execSQLFile("vexecutor/sql/drop_type.sql",
"vexecutor/ans/drop_type.ans");
}
@@ -91,18 +69,25 @@ TEST_F(TestVexecutor, scanframework)
" stringu2 name,"
" string4 name) WITH (appendonly = true, orientation = PARQUET, pagesize = 1048576, rowgroupsize = 8388608, compresstype = SNAPPY) DISTRIBUTED RANDOMLY;");
- std::string pwd = util.getTestRootPath();
- std::string cmd = "COPY test1 FROM '" + pwd + "/vexecutor/data/tenk.data'";
- std::cout << cmd << std::endl;
- util.execute(cmd);
- util.execute("select unique1 from test1");
- util.execute("SET vectorized_executor_enable to on");
+ std::string pwd = util.getTestRootPath();
+ std::string cmd = "COPY test1 FROM '" + pwd + "/vexecutor/data/tenk.data'";
+ std::cout << cmd << std::endl;
+ util.execute(cmd);
+
+ util.execSQLFile("vexecutor/sql/create_type.sql");
+
+ util.execute("select unique1 from test1");
+ util.execute("SET vectorized_executor_enable to on");
- util.execSQLFile("vexecutor/sql/scan1.sql",
+ util.execSQLFile("vexecutor/sql/scan1.sql",
"vexecutor/ans/scan1.ans");
- util.execute("drop table test1");
-}
+ // run sql file to get ans file and then diff it with out file
+ util.execSQLFile("vexecutor/sql/drop_type.sql");
+
+ util.execute("drop table test1");
+};
+
TEST_F(TestVexecutor, scanAO)
{
@@ -127,18 +112,23 @@ TEST_F(TestVexecutor, scanAO)
" stringu2 name,"
" string4 name) WITH (appendonly = true, compresstype = SNAPPY) DISTRIBUTED RANDOMLY;");
- std::string pwd = util.getTestRootPath();
- std::string cmd = "COPY test1 FROM '" + pwd + "/vexecutor/data/tenk.data'";
- std::cout << cmd << std::endl;
- util.execute(cmd);
- util.execute("select unique1 from test1");
- util.execute("SET vectorized_executor_enable to on");
+ std::string pwd = util.getTestRootPath();
+ std::string cmd = "COPY test1 FROM '" + pwd + "/vexecutor/data/tenk.data'";
+ std::cout << cmd << std::endl;
+ util.execute(cmd);
+ util.execSQLFile("vexecutor/sql/create_type.sql");
+
+ util.execute("select unique1 from test1");
+ util.execute("SET vectorized_executor_enable to on");
- util.execSQLFile("vexecutor/sql/scan1.sql",
+ util.execSQLFile("vexecutor/sql/scan1.sql",
"vexecutor/ans/scan1.ans");
- util.execute("drop table test1");
-}
+ // run sql file to get ans file and then diff it with out file
+ util.execSQLFile("vexecutor/sql/drop_type.sql");
+
+ util.execute("drop table test1");
+};
TEST_F(TestVexecutor, ProjAndQual)
{
@@ -148,6 +138,8 @@ TEST_F(TestVexecutor, ProjAndQual)
util.execute("create table test1 (a int, b int, c int, d int);");
util.execute("insert into test1 select generate_series(1,1024), 1, 1, 1;");
+ util.execSQLFile("vexecutor/sql/create_type.sql");
+
util.execSQLFile("vexecutor/sql/projandqual.sql",
"vexecutor/ans/projandqual.ans");
@@ -156,22 +148,76 @@ TEST_F(TestVexecutor, ProjAndQual)
util.execSQLFile("vexecutor/sql/projandqual.sql",
"vexecutor/ans/projandqual.ans");
- util.execute("drop table test1");
-}
+ // run sql file to get ans file and then diff it with out file
+ util.execSQLFile("vexecutor/sql/drop_type.sql");
+ util.execute("drop table test1");
+};
TEST_F(TestVexecutor, date)
+ {
+ hawq::test::SQLUtility util;
+ util.execute("drop table if exists test1");
+ util.execute("create table test1 (a date,i int) WITH (appendonly = true, compresstype = SNAPPY) DISTRIBUTED RANDOMLY;");
+ util.execute("insert into test1 select '1998-03-28'::date + generate_series(1,2000), 1;");
+ util.execute("select a + i from test1;");
+
+ util.execSQLFile("vexecutor/sql/create_type.sql");
+
+ util.execute("SET vectorized_executor_enable to on");
+
+ util.execSQLFile("vexecutor/sql/vdate.sql",
+ "vexecutor/ans/vdate.ans");
+
+ // run sql file to get ans file and then diff it with out file
+ util.execSQLFile("vexecutor/sql/drop_type.sql");
+
+ util.execute("drop table test1");
+ }
+
+TEST_F(TestVexecutor, vagg)
{
hawq::test::SQLUtility util;
- util.execute("drop table if exists test1");
- util.execute("create table test1 (a date,i int) WITH (appendonly = true, compresstype = SNAPPY) DISTRIBUTED RANDOMLY;");
- util.execute("insert into test1 select '1998-03-28'::date + generate_series(1,2000), 1;");
- util.execute("select a + i from test1;");
+
+ util.execute("create table test_int2(a int2, b int2, c int2)");
+ util.execute("create table test_int4(a int4, b int4, c int4)");
+ util.execute("create table test_int8(a int8, b int8, c int8)");
+ util.execute("create table test_float4(a float4, b float4, c float4)");
+ util.execute("create table test_float8(a float8, b float8, c float8)");
+
+ util.execute("insert into test_int2 select generate_series(1,16),1,2");
+ util.execute("insert into test_int4 select generate_series(1,16),1,2");
+ util.execute("insert into test_int8 select generate_series(1,16),1,2");
+ util.execute("insert into test_float4 select generate_series(1,16),1,2");
+ util.execute("insert into test_float8 select generate_series(1,16),1,2");
+
+ util.execute("insert into test_int2 select null, null, null");
+ util.execute("insert into test_int4 select null, null, null");
+ util.execute("insert into test_int8 select null, null, null");
+ util.execute("insert into test_float4 select null, null, null");
+ util.execute("insert into test_float8 select null, null, null");
+
+
+ // run sql file to get ans file and then diff it with out file
+ util.execSQLFile("vexecutor/sql/create_type.sql");
+
+ util.execSQLFile("vexecutor/sql/vagg.sql",
+ "vexecutor/ans/vagg.ans");
util.execute("SET vectorized_executor_enable to on");
+ util.execute("SET vectorized_batch_size = 4");
+
+ util.execSQLFile("vexecutor/sql/vagg.sql",
+ "vexecutor/ans/vagg.ans");
+
+ // run sql file to get ans file and then diff it with out file
+ util.execSQLFile("vexecutor/sql/drop_type.sql");
+
+ util.execute("drop table if exists test_int2");
+ util.execute("drop table if exists test_int4");
+ util.execute("drop table if exists test_int8");
+ util.execute("drop table if exists test_float4");
+ util.execute("drop table if exists test_float8");
+};
- util.execSQLFile("vexecutor/sql/vdate.sql",
- "vexecutor/ans/vdate.ans");
- util.execute("drop table test1");
-}
[6/9] incubator-hawq git commit: HAWQ-1612. Implement vectorized
aggregate functions, such as avg/sum/count.
Posted by rl...@apache.org.
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/ce2814d4/contrib/vexecutor/execVScan.c
----------------------------------------------------------------------
diff --git a/contrib/vexecutor/execVScan.c b/contrib/vexecutor/execVScan.c
index 911a49d..064dfed 100644
--- a/contrib/vexecutor/execVScan.c
+++ b/contrib/vexecutor/execVScan.c
@@ -66,9 +66,10 @@ getVScanMethod(int tableType)
TupleTableSlot *ExecTableVScanVirtualLayer(ScanState *scanState)
{
VectorizedState* vs = (VectorizedState*)scanState->ps.vectorized;
- VectorizedState* pvs = vs->parent->vectorized;
- if(pvs->vectorized)
+ /* if vs->parent is NULL, it represent that the parent is non-vectorized */
+ if(vs->parent && vs->parent->vectorized &&
+ ((VectorizedState*)vs->parent->vectorized)->vectorized)
return ExecTableVScan(scanState);
else
{
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/ce2814d4/contrib/vexecutor/vagg.c
----------------------------------------------------------------------
diff --git a/contrib/vexecutor/vagg.c b/contrib/vexecutor/vagg.c
new file mode 100644
index 0000000..b5baf77
--- /dev/null
+++ b/contrib/vexecutor/vagg.c
@@ -0,0 +1,2236 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include <unistd.h>
+#include "postgres.h"
+#include "fmgr.h"
+#include "miscadmin.h"
+#include "access/hash.h"
+#include "catalog/catquery.h"
+#include "catalog/pg_aggregate.h"
+#include "catalog/pg_proc.h"
+#include "cdb/cdbexplain.h"
+#include "cdb/cdbvars.h"
+#include "executor/execHHashagg.h"
+#include "executor/instrument.h"
+#include "nodes/pg_list.h"
+#include "optimizer/clauses.h"
+#include "optimizer/tlist.h"
+#include "parser/parse_agg.h"
+#include "parser/parse_coerce.h"
+#include "parser/parse_expr.h"
+#include "parser/parse_oper.h"
+#include "utils/acl.h"
+#include "utils/array.h"
+#include "utils/builtins.h"
+#include "utils/lsyscache.h"
+#include "utils/numeric.h"
+
+#include "vagg.h"
+#include "vtype.h"
+#include "execVQual.h"
+#include "tuplebatch.h"
+#include "vexecutor.h"
+
+#define HHA_MSG_LVL DEBUG2
+
+extern int BATCHSIZE;
+
+/*
+ * copy from src/backend/executor/execHHashagg.c
+ * Represent different types for input records to be inserted
+ * into the hash table.
+ */
+#define GET_BUFFER_SIZE(hashtable) \
+ ((hashtable)->entry_buf.nfull_total * (hashtable)->entry_buf.cellbytes + \
+ mpool_total_bytes_allocated((hashtable)->group_buf))
+
+#define GET_USED_BUFFER_SIZE(hashtable) \
+ ((hashtable)->entry_buf.nfull_total * (hashtable)->entry_buf.cellbytes + \
+ mpool_bytes_used((hashtable)->group_buf))
+
+#define SANITY_CHECK_METADATA_SIZE(hashtable) \
+ do { \
+ if ((hashtable)->mem_for_metadata >= (hashtable)->max_mem) \
+ ereport(ERROR, (errcode(ERRCODE_GP_INTERNAL_ERROR), \
+ errmsg(ERRMSG_GP_INSUFFICIENT_STATEMENT_MEMORY)));\
+ } while (0)
+
+#define GET_TOTAL_USED_SIZE(hashtable) \
+ (GET_USED_BUFFER_SIZE(hashtable) + (hashtable)->mem_for_metadata)
+
+#define HAVE_FREESPACE(hashtable) \
+ (GET_TOTAL_USED_SIZE(hashtable) < (hashtable)->max_mem)
+
+
+/*
+ * implement the SUM aggregate functions.
+ * With the different column type of aggregate function, the transfer
+ * data type is different too.
+ *
+ * this MACRO only used by the int2 and int4.
+ */
+#define _VACCUM_NUMERIC(type) \
+PG_FUNCTION_INFO_V1(v##type##_accum); \
+Datum v##type##_accum(PG_FUNCTION_ARGS) \
+{ \
+ VectorizedAggData *vectransdata = \
+ (VectorizedAggData *) PG_GETARG_BYTEA_P(0); \
+ BatchAggGroupData *groupdata = vectransdata->groupData; \
+ GroupData *curHeader = NULL; \
+ v##type *vvalue = (v##type *)DatumGetPointer(PG_GETARG_DATUM(1)); \
+ int idx = 0;\
+ int64 sum = 0; \
+ bool allnull = true; \
+ Assert(NULL != vectransdata); \
+ if(NULL != groupdata) \
+ { \
+ curHeader = &(groupdata->group_header[groupdata->group_idx]); \
+ } \
+ if(vectransdata->isnovalue) \
+ { \
+ vectransdata->data = 0; \
+ vectransdata->isnull = true; \
+ vectransdata->isnovalue = false; \
+ } \
+ if(curHeader) \
+ { \
+ for(idx = curHeader->idx; idx != -1; idx = groupdata->idx_list[idx]) \
+ { \
+ Assert(NULL != vvalue->isnull); \
+ if(vvalue->isnull[idx]) \
+ continue; \
+ if(NULL != vectransdata->skip && vectransdata->skip[idx]) \
+ continue; \
+ allnull = false; \
+ sum = sum + vvalue->values[idx];\
+ } \
+ } \
+ else \
+ { \
+ for(idx = 0; idx < vvalue->dim; idx++) \
+ { \
+ Assert(NULL != vvalue->isnull); \
+ if(vvalue->isnull[idx]) \
+ continue; \
+ if(NULL != vectransdata->skip && vectransdata->skip[idx]) \
+ continue; \
+ allnull = false; \
+ sum = sum + vvalue->values[idx];\
+ } \
+ } \
+ if(!allnull) \
+ vectransdata->isnull = false; \
+ vectransdata->data += sum; \
+ return PointerGetDatum(vectransdata); \
+}
+
+/*
+ * for sum(int8)
+ * the transfer data type of sum(int8) is numeric
+ */
+PG_FUNCTION_INFO_V1(vint8_accum);
+Datum vint8_accum(PG_FUNCTION_ARGS)
+{
+ VectorizedAggData *vectransdata =
+ (VectorizedAggData *) PG_GETARG_BYTEA_P(0);
+ BatchAggGroupData *groupdata = vectransdata->groupData;
+ GroupData *curHeader = NULL;
+ vint8 *vvalue = (vint8 *)DatumGetPointer(PG_GETARG_DATUM(1));
+ int idx = 0;
+ int64 sum = 0;
+ Datum newval;
+ bool allnull = true;
+ Assert(NULL != vectransdata);
+ if(NULL != groupdata)
+ {
+ curHeader = &(groupdata->group_header[groupdata->group_idx]);
+ }
+ if( vectransdata->isnull || vectransdata->isnovalue)
+ {
+ vectransdata->data = DirectFunctionCall1(int8_numeric, Int64GetDatum(0));
+ vectransdata->isnull = true;
+ vectransdata->isnovalue = false;
+ vectransdata->isalloc = true;
+ }
+
+ if(curHeader)
+ {
+ for(idx = curHeader->idx; idx != -1; idx = groupdata->idx_list[idx])
+ {
+ Assert(NULL != vvalue->isnull);
+ if(vvalue->isnull[idx])
+ continue;
+ if(NULL != vectransdata->skip && vectransdata->skip[idx])
+ continue;
+ sum = sum + DatumGetInt64(vvalue->values[idx]);
+ allnull = false;
+ }
+ }
+ else
+ {
+ for(idx = 0; idx < vvalue->dim; idx++)
+ {
+ Assert(NULL != vvalue->isnull);
+ if(vvalue->isnull[idx])
+ continue;
+ if(NULL != vectransdata->skip && vectransdata->skip[idx])
+ continue;
+ sum = sum + DatumGetInt64(vvalue->values[idx]);
+ allnull = false;
+ }
+ }
+
+ if(!allnull)
+ {
+ vectransdata->isnull = false;
+ vectransdata->isalloc = true;
+ /* OK to do the addition. */
+ newval = DirectFunctionCall1(int8_numeric, Int64GetDatum(sum));
+ vectransdata->data = DirectFunctionCall2(numeric_add,
+ vectransdata->data, newval);
+ }
+ return PointerGetDatum(vectransdata);
+}
+
+/*
+ * for sum(float4)
+ * the transfer data type of sum(float4) is float4
+ */
+PG_FUNCTION_INFO_V1(vfloat4_accum);
+Datum vfloat4_accum(PG_FUNCTION_ARGS)
+{
+ VectorizedAggData *vectransdata =
+ (VectorizedAggData *) PG_GETARG_BYTEA_P(0);
+ BatchAggGroupData *groupdata = vectransdata->groupData;
+ GroupData *curHeader = NULL;
+ vfloat4 *vvalue = (vfloat4 *)DatumGetPointer(PG_GETARG_DATUM(1));
+ int idx = 0;
+ float4 sum = 0;
+ bool allnull = true;
+ Datum newval;
+ Assert(NULL != vectransdata);
+ if(NULL != groupdata)
+ {
+ curHeader = &(groupdata->group_header[groupdata->group_idx]);
+ }
+ if( vectransdata->isnull || vectransdata->isnovalue)
+ {
+ vectransdata->data = Float4GetDatum(0);
+ vectransdata->isnull = true;
+ vectransdata->isnovalue = false;
+ }
+
+ if(curHeader)
+ {
+ for(idx = curHeader->idx; idx != -1; idx = groupdata->idx_list[idx])
+ {
+ Assert(NULL != vvalue->isnull);
+ if(vvalue->isnull[idx])
+ continue;
+ if(NULL != vectransdata->skip && vectransdata->skip[idx])
+ continue;
+ sum = sum + DatumGetFloat4(vvalue->values[idx]);
+ allnull = false;
+ }
+ }
+ else
+ {
+ for(idx = 0; idx < vvalue->dim; idx++)
+ {
+ Assert(NULL != vvalue->isnull);
+ if(vvalue->isnull[idx])
+ continue;
+ if(NULL != vectransdata->skip && vectransdata->skip[idx])
+ continue;
+ sum = sum + DatumGetFloat4(vvalue->values[idx]);
+ allnull = false;
+ }
+ }
+
+ if(!allnull)
+ vectransdata->isnull = false;
+
+ /* OK to do the addition. */
+ sum = sum + DatumGetFloat4(vectransdata->data);
+ vectransdata->data = Float4GetDatum(sum);
+ return PointerGetDatum(vectransdata);
+}
+
+/*
+ * for sum(float8)
+ * the transfer data type of sum(float8) is float8
+ */
+PG_FUNCTION_INFO_V1(vfloat8_accum);
+Datum vfloat8_accum(PG_FUNCTION_ARGS)
+{
+ VectorizedAggData *vectransdata =
+ (VectorizedAggData *) PG_GETARG_BYTEA_P(0);
+ BatchAggGroupData *groupdata = vectransdata->groupData;
+ GroupData *curHeader = NULL;
+ vfloat8 *vvalue = (vfloat8 *)DatumGetPointer(PG_GETARG_DATUM(1));
+ int idx = 0;
+ float8 sum = 0;
+ bool allnull = true;
+ Datum newval;
+ Assert(NULL != vectransdata);
+ if(NULL != groupdata)
+ {
+ curHeader = &(groupdata->group_header[groupdata->group_idx]);
+ }
+ if( vectransdata->isnull || vectransdata->isnovalue)
+ {
+ vectransdata->data = Float8GetDatum(0);
+ vectransdata->isnull = true;
+ vectransdata->isnovalue = false;
+ }
+
+ if(curHeader)
+ {
+ for(idx = curHeader->idx; idx != -1; idx = groupdata->idx_list[idx])
+ {
+ Assert(NULL != vvalue->isnull);
+ if(vvalue->isnull[idx])
+ continue;
+ if(NULL != vectransdata->skip && vectransdata->skip[idx])
+ continue;
+ sum = sum + DatumGetFloat8(vvalue->values[idx]);
+ allnull = false;
+ }
+ }
+ else
+ {
+ for(idx = 0; idx < vvalue->dim; idx++)
+ {
+ Assert(NULL != vvalue->isnull);
+ if(vvalue->isnull[idx])
+ continue;
+ if(NULL != vectransdata->skip && vectransdata->skip[idx])
+ continue;
+ sum = sum + DatumGetFloat8(vvalue->values[idx]);
+ allnull = false;
+ }
+ }
+
+ if(!allnull)
+ vectransdata->isnull = false;
+
+ /* OK to do the addition. */
+ sum = sum + DatumGetFloat8(vectransdata->data);
+ vectransdata->data = Float8GetDatumFast(sum);
+ return PointerGetDatum(vectransdata);
+}
+
+/*
+ * implement the AVG aggregate functions.
+ */
+#define _VAVG_NUMERIC(type, XTYPE) \
+PG_FUNCTION_INFO_V1(v##type##_avg_accum); \
+Datum v##type##_avg_accum(PG_FUNCTION_ARGS) \
+{ \
+ VectorizedAggData *vectransdata = \
+ (VectorizedAggData *) PG_GETARG_BYTEA_P(0); \
+ IntFloatAvgTransdata *transdata = NULL;\
+ BatchAggGroupData *groupdata = vectransdata->groupData; \
+ GroupData *curHeader = NULL; \
+ v##type *vvalue = (v##type *)DatumGetPointer(PG_GETARG_DATUM(1)); \
+ int idx = 0;\
+ int64 count = 0; \
+ float8 sum = 0; \
+ Assert(NULL != vectransdata); \
+ if(NULL != groupdata) \
+ { \
+ curHeader = &(groupdata->group_header[groupdata->group_idx]); \
+ } \
+ if(vectransdata->isnull || vectransdata->isnovalue) \
+ { \
+ transdata = \
+ (IntFloatAvgTransdata *) palloc(sizeof(IntFloatAvgTransdata)); \
+ SET_VARSIZE(transdata, sizeof(IntFloatAvgTransdata)); \
+ transdata->count = 0; \
+ transdata->sum = 0; \
+ vectransdata->isnull = false; \
+ vectransdata->isnovalue = false; \
+ vectransdata->isalloc = true;\
+ vectransdata->data = PointerGetDatum(transdata); \
+ } \
+ else \
+ { \
+ transdata= (IntFloatAvgTransdata*)DatumGetPointer(vectransdata->data);\
+ } \
+ if(curHeader) \
+ { \
+ for(idx = curHeader->idx; idx != -1; idx = groupdata->idx_list[idx]) \
+ { \
+ Assert(NULL != vvalue->isnull); \
+ if(vvalue->isnull[idx]) \
+ continue; \
+ if(NULL != vectransdata->skip && vectransdata->skip[idx]) \
+ continue; \
+ sum = sum + DatumGet##XTYPE(vvalue->values[idx]);\
+ count++; \
+ } \
+ } \
+ else \
+ { \
+ for(idx = 0; idx < vvalue->dim; idx++) \
+ { \
+ if(vvalue->isnull[idx]) \
+ continue; \
+ if(NULL != vectransdata->skip && vectransdata->skip[idx]) \
+ continue; \
+ sum = sum + DatumGet##XTYPE(vvalue->values[idx]);\
+ count++; \
+ } \
+ } \
+ transdata->count += count; \
+ transdata->sum += sum; \
+ return PointerGetDatum(vectransdata); \
+}
+
+
+/*
+ * implement the COUNT(column) aggregate functions.
+ */
+#define _VINC_NUMERIC(type) \
+PG_FUNCTION_INFO_V1(v##type##_inc); \
+Datum v##type##_inc(PG_FUNCTION_ARGS) \
+{ \
+ VectorizedAggData *vectransdata = \
+ (VectorizedAggData *) PG_GETARG_BYTEA_P(0); \
+ BatchAggGroupData *groupdata = vectransdata->groupData; \
+ GroupData *curHeader = NULL; \
+ int64 tval = 0; \
+ v##type* vvalue = (v##type *)DatumGetPointer(PG_GETARG_DATUM(1)); \
+ int idx; \
+ Assert(NULL != vectransdata); \
+ if(NULL != groupdata) \
+ { \
+ curHeader = &(groupdata->group_header[groupdata->group_idx]); \
+ } \
+ if( vectransdata->isnull || vectransdata->isnovalue) \
+ { \
+ vectransdata->data = Int64GetDatum(0); \
+ vectransdata->isnull = false; \
+ vectransdata->isnovalue = false; \
+ } \
+ if(curHeader) \
+ { \
+ Assert(NULL != vvalue->isnull); \
+ for(idx = curHeader->idx; idx != -1; idx = groupdata->idx_list[idx]) \
+ { \
+ if(vvalue->isnull[idx]) \
+ continue; \
+ if(NULL != vectransdata->skip && vectransdata->skip[idx]) \
+ continue; \
+ tval++; \
+ } \
+ } \
+ else \
+ { \
+ Assert(NULL != vvalue->isnull); \
+ for(idx = 0; idx < vvalue->dim; idx++) \
+ { \
+ if(vvalue->isnull[idx]) \
+ continue; \
+ if(NULL != vectransdata->skip && vectransdata->skip[idx]) \
+ continue; \
+ tval++; \
+ } \
+ } \
+ vectransdata->data = (vectransdata->data + tval); \
+ return PointerGetDatum(vectransdata); \
+}
+
+
+/*
+ * implement the COUNT(*) aggregate functions.
+ * NOTE:we create an new aggregate functions 'veccount' to implement the
+ * vectorized couter aggregate, In the CHECK phase(vcheck.c), if we found
+ * an count(*), we use veccount(*) to replace it.
+ */
+PG_FUNCTION_INFO_V1(vec_inc_any);
+Datum vec_inc_any(PG_FUNCTION_ARGS)
+{
+ VectorizedAggData *vectransdata =
+ (VectorizedAggData *) PG_GETARG_BYTEA_P(0);
+ BatchAggGroupData *groupdata = vectransdata->groupData;
+ GroupData *curHeader = NULL;
+ int64 tval = 0;
+ int idx;
+ Assert(NULL != vectransdata);
+ if(NULL != groupdata)
+ {
+ curHeader = &(groupdata->group_header[groupdata->group_idx]);
+ }
+ if( vectransdata->isnull || vectransdata->isnovalue)
+ {
+ vectransdata->data = Int64GetDatum(0);
+ vectransdata->isnull = false;
+ vectransdata->isnovalue = false;
+ }
+ if(curHeader)
+ {
+ for(idx = curHeader->idx; idx != -1; idx = groupdata->idx_list[idx])
+ {
+ if(NULL != vectransdata->skip && vectransdata->skip[idx])
+ continue;
+ tval++;
+ }
+ }
+ else
+ {
+ for(idx = 0; idx < vectransdata->nrows; idx++)
+ {
+ if(NULL != vectransdata->skip && vectransdata->skip[idx])
+ continue;
+ tval++;
+ }
+ }
+ vectransdata->data = Int64GetDatum(DatumGetInt64(vectransdata->data) + tval);
+ return PointerGetDatum(vectransdata);
+}
+
+_VACCUM_NUMERIC(int2)
+_VACCUM_NUMERIC(int4)
+
+#define VACCUM_NUMERIC(type, XTYPE) \
+ _VAVG_NUMERIC(type, XTYPE) \
+ _VINC_NUMERIC(type)
+
+VACCUM_NUMERIC(int2, Int16)
+VACCUM_NUMERIC(int4, Int32)
+VACCUM_NUMERIC(int8, Int64)
+VACCUM_NUMERIC(float4, Float4)
+VACCUM_NUMERIC(float8, Float8)
+
+
+/*
+ * copy from src/backend/executor/nodeagg.c
+ *
+ * Advance all the aggregates for one input tuple. The input tuple
+ * has been stored in tmpcontext->ecxt_scantuple, so that it is accessible
+ * to ExecEvalExpr. pergroup is the array of per-group structs to use
+ * (this might be in a hashtable entry).
+ *
+ * When called, CurrentMemoryContext should be the per-query context.
+ */
+static void
+advance_vaggregates(AggState *aggstate, AggStatePerGroup pergroup,
+ MemoryManagerContainer *mem_manager)
+{
+ int aggno;
+ TupleBatch tb;
+ VectorizedState *vstate = ((PlanState*)aggstate)->vectorized;
+
+ Assert(NULL != vstate);
+
+ for (aggno = 0; aggno < aggstate->numaggs; aggno++)
+ {
+ AggStatePerAgg peraggstate = &aggstate->peragg[aggno];
+ AggStatePerGroup pergroupstate = &pergroup[aggno];
+ Aggref *aggref = peraggstate->aggref;
+ PercentileExpr *perc = peraggstate->perc;
+ int i;
+ TupleTableSlot *slot;
+ int nargs;
+
+ /* We can apply the transition function immediately */
+ FunctionCallInfoData fcinfo;
+
+ if (aggref)
+ nargs = list_length(aggref->args);
+ else
+ {
+ Assert (perc);
+ nargs = list_length(perc->args);
+ }
+
+ /* Evaluate the current input expressions for this aggregate */
+ Assert(NULL != vastate->aggslot);
+ slot = vstate->aggslot[aggno];
+
+ Assert(NULL != slot);
+
+ tb = (TupleBatch)slot->PRIVATE_tb;
+
+ /* Load values into fcinfo */
+ /* Start from 1, since the 0th arg will be the transition value */
+ if (aggref)
+ {
+ for (i = 0; i < nargs; i++)
+ {
+ tb->datagroup[i]->skipref = tb->skip;
+ fcinfo.arg[i + 1] = PointerGetDatum(tb->datagroup[i]);
+ fcinfo.argnull[i + 1] = false;
+ }
+
+ }
+ else
+ {
+ /*
+ * In case of percentile functions, put everything into
+ * fcinfo's argument since there should be the required
+ * attributes as arguments in the tuple.
+ */
+ int natts;
+
+ Assert(perc);
+ natts = slot->tts_tupleDescriptor->natts;
+ for (i = 0; i < natts; i++)
+ {
+ fcinfo.arg[i + 1] = PointerGetDatum(tb->datagroup[i]);
+ fcinfo.argnull[i + 1] = false;
+ }
+ }
+
+ advance_transition_function(aggstate, peraggstate, pergroupstate,
+ &fcinfo, mem_manager);
+ } /* aggno loop */
+}
+
+/*
+ * copy from src/backend/executor/nodeagg.c
+ * Function: setGroupAggs
+ *
+ * Set the groupaggs buffer in the hashtable to point to the right place
+ * in the given hash entry.
+ */
+static inline void
+setGroupAggs(HashAggTable *hashtable, MemTupleBinding *mt_bind, HashAggEntry *entry)
+{
+ Assert(mt_bind != NULL);
+
+ if (entry != NULL)
+ {
+ int tup_len = memtuple_get_size((MemTuple)entry->tuple_and_aggs, mt_bind);
+ hashtable->groupaggs->tuple = (MemTuple)entry->tuple_and_aggs;
+ hashtable->groupaggs->aggs = (AggStatePerGroup)
+ ((char *)entry->tuple_and_aggs + MAXALIGN(tup_len));
+ }
+}
+
+/*
+ * copy from src/backend/executor/execHHashagg.c
+ *
+ * Calculate the hash value for the given input tuple.
+ *
+ * This based on but different from get_hash_value from the dynahash
+ * API. Use a different name to underline that we don't use dynahash.
+ */
+static uint32
+calc_hash_value(AggState* aggstate, TupleTableSlot *inputslot)
+{
+ Agg *agg;
+ ExprContext *econtext;
+ MemoryContext oldContext;
+ int i;
+ FmgrInfo* info = aggstate->hashfunctions;
+ HashAggTable *hashtable = aggstate->hhashtable;
+
+ agg = (Agg*)aggstate->ss.ps.plan;
+ econtext = aggstate->tmpcontext; /* short-lived, per-input-tuple */
+
+ oldContext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
+
+ for (i = 0; i < agg->numCols; i++, info++)
+ {
+ AttrNumber att = agg->grpColIdx[i];
+ bool isnull = false;
+ Datum value = slot_getattr(inputslot, att, &isnull);
+
+ if (!isnull) /* treat nulls as having hash key 0 */
+ {
+ hashtable->hashkey_buf[i] = DatumGetUInt32(FunctionCall1(info, value));
+ }
+
+ else
+ hashtable->hashkey_buf[i] = 0xdeadbeef;
+
+ }
+
+ MemoryContextSwitchTo(oldContext);
+ return (uint32) hash_any((unsigned char *) hashtable->hashkey_buf, agg->numCols * sizeof(HashKey));
+}
+
+/*
+ * Vectorized Data
+ *
+ * To implement an aggregate function often have 3 phase:
+ * 1) Set the initialized values.
+ * 2) process data, it used "transfer data" for communication.
+ * 3) finalize aggregate functions, to get the final result.
+ * To implement the vectorized aggregate functions, we refactor the phase 2.
+ * we don't use the "transfer data" directly when the aggregate functions
+ * can be vectorized, we create a VectorizedAggData to encapsulates the
+ * "transfer data", and also set the groupping data in it, then the vectorized
+ * aggregate functions can get the grouping data and process it.
+ * Because "transfer data" is used as a Datum, and we use
+ * VectorizedAggData as a Datum too, so it can communicate properly.
+ * when the phase 2 is over, we strip the VectorizedAggData, it convert to
+ * "transfer data" again.
+ * Because the result of phase 2 is a scalar, so we
+ * can use the non-vectorized finalize aggregate functions directly.
+ */
+
+/*
+ * Init Vectorized data, in order to transfer group data into the agg functions
+ */
+VectorizedAggData *
+InitAggVectorizedData(AggState *aggstate)
+{
+ int aggno;
+
+ VectorizedAggData *trans =
+ (VectorizedAggData *) palloc0(sizeof(VectorizedAggData) * aggstate->numaggs);
+
+ for (aggno = 0; aggno < aggstate->numaggs; aggno++)
+ {
+ SET_VARSIZE(&trans[aggno], sizeof(VectorizedAggData));
+ }
+
+ return trans;
+}
+
+/*
+ * Use the new transfer data, it can send the group data to agg functions.
+ */
+static inline void
+AddAggVectorizedData(AggState *aggstate,
+ AggStatePerGroup pergroup, VectorizedAggData *trans,
+ BatchAggGroupData *groupdata, bool *skip, int nrows)
+{
+ int aggno;
+
+ for (aggno = 0; aggno < aggstate->numaggs; aggno++)
+ {
+ AggStatePerGroup pergroupstate = &pergroup[aggno];
+ trans[aggno].data = pergroupstate->transValue;
+ trans[aggno].isnull = pergroupstate->transValueIsNull;
+ trans[aggno].isnovalue = pergroupstate->noTransValue;
+ trans[aggno].groupData = groupdata;
+ trans[aggno].skip = skip;
+ trans[aggno].nrows = nrows;
+ trans[aggno].isalloc = false;
+ pergroupstate->transValueIsNull = false;
+ pergroupstate->noTransValue = false;
+ pergroupstate->transValue = PointerGetDatum(&(trans[aggno]));
+ }
+
+ return;
+}
+
+/*
+ * set skip array to filter some tuples
+ */
+static inline void
+SetAggVectorizedSkip(AggState *aggstate, VectorizedAggData *trans, bool *skip, int nrows)
+{
+ int aggno;
+
+ for (aggno = 0; aggno < aggstate->numaggs; aggno++)
+ {
+ trans[aggno].skip = skip;
+ trans[aggno].nrows = nrows;
+ }
+
+ return;
+}
+
+/*
+ * remove the vectorized data struct
+ */
+static inline void
+RemoveAggVectorizedData(AggState *aggstate,
+ AggStatePerGroup pergroup)
+{
+ int aggno;
+ MemoryManagerContainer *mem_manager = &(aggstate->mem_manager);
+
+ for (aggno = 0; aggno < aggstate->numaggs; aggno++)
+ {
+ AggStatePerGroup pergroupstate = &pergroup[aggno];
+ AggStatePerAgg peraggstate = &aggstate->peragg[aggno];
+ VectorizedAggData *trans =
+ (VectorizedAggData *) DatumGetPointer(pergroupstate->transValue);
+
+ pergroupstate->transValueIsNull = trans->isnull;
+ pergroupstate->noTransValue = trans->isnovalue;
+ if(trans->isalloc)
+ pergroupstate->transValue = datumCopyWithMemManager(0,
+ trans->data,
+ peraggstate->transtypeByVal,
+ peraggstate->transtypeLen,
+ mem_manager);
+ else
+ pergroupstate->transValue = trans->data;
+ }
+
+ return;
+}
+
+
+/*
+ * copied from src/backend/executor/execHHashagg.c
+ * agg_hash_table_stat_upd
+ * collect hash chain statistics for EXPLAIN ANALYZE
+ */
+static void
+agg_hash_table_stat_upd(HashAggTable *ht)
+{
+ unsigned int i;
+
+ char hostname[SEGMENT_IDENTITY_NAME_LENGTH];
+ gethostname(hostname,SEGMENT_IDENTITY_NAME_LENGTH);
+ for (i = 0; i < ht->nbuckets; i++)
+ {
+ HashAggEntry *entry = ht->buckets[i];
+ int chainlength = 0;
+
+ if (entry)
+ {
+ for (chainlength = 0; entry; chainlength++)
+ entry = entry->next;
+
+ cdbexplain_agg_upd(&ht->chainlength, chainlength, i,hostname);
+ }
+ }
+} /* agg_hash_table_stat_upd */
+
+/*
+ * copied from src/backend/executor/nodeAgg.c
+ *
+ * agg_retrieve_scalar
+ * Compute the scalar aggregates.
+ *
+ */
+static TupleTableSlot *
+agg_retrieve_scalar(AggState *aggstate)
+{
+ AggStatePerAgg peragg = aggstate->peragg;
+ AggStatePerGroup pergroup = aggstate->pergroup ;
+ VectorizedState *vstate = ((PlanState*)aggstate)->vectorized;
+ VectorizedAggData *trans = (VectorizedAggData*)vstate->transdata;
+
+ initialize_aggregates(aggstate, peragg, pergroup, &(aggstate->mem_manager));
+
+ /*
+ * In fact if there is no Group By clause, VectorizedData is not useful,
+ * we add it in order to keep compatibility.
+ */
+ AddAggVectorizedData(aggstate, pergroup, trans, NULL, NULL, 0);
+
+ /*
+ * We loop through input tuples, and compute the aggregates.
+ */
+ while (!aggstate->agg_done)
+ {
+ ExprContext *tmpcontext = aggstate->tmpcontext;
+ /* Reset the per-input-tuple context */
+ ResetExprContext(tmpcontext);
+ PlanState *outerPlan = outerPlanState(aggstate);
+ TupleTableSlot *outerslot = ExecProcNode(outerPlan);
+ TupleBatch tb = NULL;
+ if (TupIsNull(outerslot))
+ {
+ aggstate->agg_done = true;
+ break;
+ }
+ Gpmon_M_Incr(GpmonPktFromAggState(aggstate), GPMON_QEXEC_M_ROWSIN);
+ CheckSendPlanStateGpmonPkt(&aggstate->ss.ps);
+
+ tmpcontext->ecxt_scantuple = outerslot;
+
+ tb = (TupleBatch)outerslot->PRIVATE_tb;
+
+ SetAggVectorizedSkip(aggstate, trans, tb->skip, tb->nrows);
+
+ /*
+ * In fact if there is no Group By clause, we can do the
+ * projection in the advance_vaggregates.
+ * we add it in order to keep compatibility.
+ */
+ int aggno;
+ for (aggno = 0; aggno < aggstate->numaggs; aggno++)
+ {
+ AggStatePerAgg peraggstate = &aggstate->peragg[aggno];
+
+ /* Evaluate the current input expressions for this aggregate */
+ vstate->aggslot[aggno] = ExecVProject(peraggstate->evalproj, NULL);
+ }
+
+ advance_vaggregates(aggstate, pergroup, &(aggstate->mem_manager));
+ }
+
+ RemoveAggVectorizedData(aggstate, pergroup);
+
+ finalize_aggregates(aggstate, pergroup);
+
+
+ ExprContext *econtext = aggstate->ss.ps.ps_ExprContext;
+ Agg *node = (Agg*)aggstate->ss.ps.plan;
+ econtext->grouping = node->grouping;
+ econtext->group_id = node->rollupGSTimes;
+ /* Check the qual (HAVING clause). */
+ if (ExecQual(aggstate->ss.ps.qual, econtext, false))
+ {
+ Gpmon_M_Incr_Rows_Out(GpmonPktFromAggState(aggstate));
+ CheckSendPlanStateGpmonPkt(&aggstate->ss.ps);
+
+ /*
+ * Form and return a projection tuple using the aggregate results
+ * and the representative input tuple.
+ */
+ return ExecProject(aggstate->ss.ps.ps_ProjInfo, NULL);
+ }
+ return NULL;
+}
+
+/*
+ * ExecAgg for non-hashed case.
+ */
+static TupleTableSlot *
+agg_retrieve_direct(AggState *aggstate)
+{
+ if (aggstate->agg_done)
+ {
+ return NULL;
+ }
+
+ switch(aggstate->aggType)
+ {
+ case AggTypeScalar:
+ return agg_retrieve_scalar(aggstate);
+
+ case AggTypeGroup:
+ case AggTypeIntermediateRollup:
+ case AggTypeFinalRollup:
+ default:
+ insist_log(false, "invalid Agg node: type %d", aggstate->aggType);
+ }
+ return NULL;
+}
+
+
+/* copy from src/backend/executor/execHHashagg.c*/
+static bool
+agg_hash_initial_1pass(AggState *aggstate)
+{
+ HashAggTable *hashtable = aggstate->hhashtable;
+ ExprContext *tmpcontext = aggstate->tmpcontext; /* per input tuple context */
+ TupleTableSlot *outerslot = NULL;
+ bool streaming = ((Agg *) aggstate->ss.ps.plan)->streaming;
+ bool tuple_remaining = true;
+ MemTupleBinding *mt_bind = aggstate->hashslot->tts_mt_bind;
+ VectorizedState *vstate = ((PlanState*)aggstate)->vectorized;
+ VectorizedAggData *trans = (VectorizedAggData*)vstate->transdata;
+
+ Assert(hashtable);
+ AssertImply(!streaming, hashtable->state == HASHAGG_BEFORE_FIRST_PASS);
+ elog(HHA_MSG_LVL,
+ "HashAgg: initial pass -- beginning to load hash table");
+
+ /* NOTE: Now we cannot use GUC parameters directly because vexecutor is a plug-in module */
+ /* If we found cached workfiles, initialize and load the batch data here */
+ if (gp_workfile_caching && aggstate->cached_workfiles_found)
+ {
+ elog(HHA_MSG_LVL, "Found existing SFS, reloading data from %s", hashtable->work_set->path);
+ /* Initialize all structures as if we just spilled everything */
+ hashtable->spill_set = read_spill_set(aggstate);
+ aggstate->hhashtable->is_spilling = true;
+ aggstate->cached_workfiles_loaded = true;
+
+ elog(gp_workfile_caching_loglevel, "HashAgg reusing cached workfiles, initiating Squelch walker");
+ PlanState *outerNode = outerPlanState(aggstate);
+ ExecSquelchNode(outerNode);
+
+ /* tuple table initialization */
+ ScanState *scanstate = & aggstate->ss;
+ PlanState *outerPlan = outerPlanState(scanstate);
+ TupleDesc tupDesc = ExecGetResultType(outerPlan);
+
+ if (aggstate->ss.ps.instrument)
+ {
+ aggstate->ss.ps.instrument->workfileReused = true;
+ }
+
+ /* Initialize hashslot by cloning input slot. */
+ ExecSetSlotDescriptor(aggstate->hashslot, tupDesc);
+ ExecStoreAllNullTuple(aggstate->hashslot);
+ mt_bind = aggstate->hashslot->tts_mt_bind;
+
+
+ return tuple_remaining;
+ }
+
+ /*
+ * Check if an input tuple has been read, but not processed
+ * because of lack of space before streaming the results
+ * in the last call.
+ */
+ if (aggstate->hashslot->tts_tupleDescriptor != NULL &&
+ hashtable->prev_slot != NULL)
+ {
+ outerslot = hashtable->prev_slot;
+ hashtable->prev_slot = NULL;
+ }
+ else
+ {
+ outerslot = ExecProcNode(outerPlanState(aggstate));
+ }
+
+ /*
+ * Process outer-plan tuples, until we exhaust the outer plan.
+ */
+ hashtable->pass = 0;
+
+ while(true)
+ {
+ HashKey hashkey;
+ bool isNew;
+ HashAggEntry *entry;
+ TupleBatch tb;
+ int i = 0;
+ BatchAggGroupData *agg_groupdata;
+ GroupData *cur_header = NULL;
+
+ /* no more tuple. Done */
+ if (TupIsNull(outerslot))
+ {
+ tuple_remaining = false;
+ break;
+ }
+
+ Assert(NULL != vstate->batchGroupData);
+ Assert(NULL != vstate->groupData);
+ Assert(NULL != vstate->indexList);
+ memset(vstate->batchGroupData, 0, sizeof(BatchAggGroupData));
+ memset(vstate->groupData, 0, sizeof(GroupData) * BATCHSIZE);
+ memset(vstate->indexList, -1, sizeof(int) * BATCHSIZE);
+
+ agg_groupdata = vstate->batchGroupData;
+ agg_groupdata->group_header = vstate->groupData;
+ agg_groupdata->idx_list = vstate->indexList;
+
+ tb = (TupleBatch)outerslot->PRIVATE_tb;
+
+ if(NULL == tb || tb->nrows == 0)
+ {
+ tuple_remaining = false;
+ break;
+ }
+
+ /*
+ * we have to convert the vectorized tuple to non-vectorized tuple,
+ * and process it one by one.
+ * the initialize value of i is -1, because outerslot may have no
+ * valid tuple(all tuple can not pass the qualification), then -1
+ * indicate that no valid tuple. if there have valid tuple, we will
+ * reset the i to correct value.
+ */
+
+ for (i = -1; i < tb->nrows; i++)
+ {
+ if(!VirtualNodeProc(outerslot))
+ break;
+
+ /* set the correct value */
+ i = tb->iter - 1;
+
+ Gpmon_M_Incr(GpmonPktFromAggState(aggstate), GPMON_QEXEC_M_ROWSIN);
+
+ if (aggstate->hashslot->tts_tupleDescriptor == NULL)
+ {
+ int size;
+
+ /* Initialize hashslot by cloning input slot. */
+ ExecSetSlotDescriptor(aggstate->hashslot, outerslot->tts_tupleDescriptor);
+ ExecStoreAllNullTuple(aggstate->hashslot);
+ mt_bind = aggstate->hashslot->tts_mt_bind;
+
+ size = ((Agg *)aggstate->ss.ps.plan)->numCols * sizeof(HashKey);
+
+ hashtable->hashkey_buf = (HashKey *)palloc0(size);
+ hashtable->mem_for_metadata += size;
+ }
+
+ /* set up for advance_aggregates call */
+ tmpcontext->ecxt_scantuple = outerslot;
+
+ /* Find or (if there's room) build a hash table entry for the
+ * input tuple's group. */
+ hashkey = calc_hash_value(aggstate, outerslot);
+ entry = lookup_agg_hash_entry(aggstate, (void *)outerslot,
+ INPUT_RECORD_TUPLE, 0, hashkey, 0, &isNew);
+
+ if (entry == NULL)
+ {
+ if (GET_TOTAL_USED_SIZE(hashtable) > hashtable->mem_used)
+ hashtable->mem_used = GET_TOTAL_USED_SIZE(hashtable);
+
+ if (hashtable->num_ht_groups <= 1)
+ ereport(ERROR,
+ (errcode(ERRCODE_GP_INTERNAL_ERROR),
+ ERRMSG_GP_INSUFFICIENT_STATEMENT_MEMORY));
+
+ /*
+ * If stream_bottom is on, we store outerslot into hashslot, so that
+ * we can process it later.
+ */
+ if (streaming)
+ {
+ Assert(tuple_remaining);
+ hashtable->prev_slot = outerslot;
+ break;
+ }
+
+ /* CDB: Report statistics for EXPLAIN ANALYZE. */
+ if (!hashtable->is_spilling && aggstate->ss.ps.instrument)
+ agg_hash_table_stat_upd(hashtable);
+
+ spill_hash_table(aggstate);
+
+ entry = lookup_agg_hash_entry(aggstate, (void *)outerslot,
+ INPUT_RECORD_TUPLE, 0, hashkey, 0, &isNew);
+ }
+
+ if (isNew)
+ {
+ int tup_len = memtuple_get_size((MemTuple)entry->tuple_and_aggs, mt_bind);
+ setGroupAggs(hashtable, mt_bind, entry);
+ MemSet((char *)entry->tuple_and_aggs + MAXALIGN(tup_len), 0,
+ aggstate->numaggs * sizeof(AggStatePerGroupData));
+ initialize_aggregates(aggstate, aggstate->peragg, hashtable->groupaggs->aggs,
+ &(aggstate->mem_manager));
+ }
+
+ //find current group_header if exists, just O(n) find
+ for (int j = 0; j < agg_groupdata->group_cnt; j++)
+ {
+ cur_header = NULL;
+ if (agg_groupdata->group_header[j].entry == entry)
+ {
+ cur_header = &(agg_groupdata->group_header[j]);
+ break;
+ }
+ }
+
+ if (cur_header == NULL)
+ {
+ // add a new group header
+ agg_groupdata->group_header[agg_groupdata->group_cnt].idx = i;
+ agg_groupdata->group_header[agg_groupdata->group_cnt].entry = entry;
+ agg_groupdata->group_cnt++;
+ }
+ else
+ {
+ //group header already exists, just insert the current tuple to the "neck"
+ agg_groupdata->idx_list[i] = cur_header->idx;
+ cur_header->idx = i;
+ }
+ }
+
+ /*
+ * if i == -1, it indicate that all tuple in outerslot is invalid,
+ * we need not to process it.
+ */
+ if(-1 != i)
+ {
+ tmpcontext->ecxt_scantuple = outerslot;
+
+ /* To avoid wasteful duplication of work, we do the projection here */
+ int aggno;
+ for (aggno = 0; aggno < aggstate->numaggs; aggno++)
+ {
+ AggStatePerAgg peraggstate = &aggstate->peragg[aggno];
+
+ /* Evaluate the current input expressions for this aggregate */
+ vstate->aggslot[aggno] = ExecVProject(peraggstate->evalproj, NULL);
+ }
+
+ /* we have known the group counts, so we process it one by one. */
+ for (int i = 0; i < agg_groupdata->group_cnt; i++) {
+ GroupData *cur_header = &(agg_groupdata->group_header[i]);
+ agg_groupdata->group_idx = i;
+
+ //set hashtable->groupaggs to the agg_hash_entry
+ setGroupAggs(hashtable, aggstate->hashslot->tts_mt_bind, cur_header->entry);
+
+ /* HACK... */
+ AddAggVectorizedData(aggstate, hashtable->groupaggs->aggs, trans, agg_groupdata, tb->skip, tb->nrows);
+ advance_vaggregates(aggstate, hashtable->groupaggs->aggs, &(aggstate->mem_manager));
+ RemoveAggVectorizedData(aggstate, hashtable->groupaggs->aggs);
+
+ }
+
+ /* it is batch count now */
+ hashtable->num_tuples++;
+
+ /* Reset per-input-tuple context after each tuple */
+ ResetExprContext(tmpcontext);
+
+ if (streaming && !HAVE_FREESPACE(hashtable))
+ {
+ Assert(tuple_remaining);
+ ExecClearTuple(aggstate->hashslot);
+ break;
+ }
+ }
+
+ /* Read the next tuple */
+ outerslot = ExecProcNode(outerPlanState(aggstate));
+ }
+
+ if (GET_TOTAL_USED_SIZE(hashtable) > hashtable->mem_used)
+ hashtable->mem_used = GET_TOTAL_USED_SIZE(hashtable);
+
+ if (hashtable->is_spilling)
+ {
+ int freed_size = 0;
+
+ /*
+ * Split out the rest of groups in the hashtable if spilling has already
+ * happened. This is because none of these groups can be immediately outputted
+ * any more.
+ */
+ spill_hash_table(aggstate);
+ freed_size = suspendSpillFiles(hashtable->spill_set);
+ hashtable->mem_for_metadata -= freed_size;
+
+ if (aggstate->ss.ps.instrument)
+ {
+ aggstate->ss.ps.instrument->workfileCreated = true;
+ }
+ }
+
+ /* CDB: Report statistics for EXPLAIN ANALYZE. */
+ if (!hashtable->is_spilling && aggstate->ss.ps.instrument)
+ agg_hash_table_stat_upd(hashtable);
+
+ AssertImply(tuple_remaining, streaming);
+ if(tuple_remaining)
+ elog(HHA_MSG_LVL, "HashAgg: streaming out the intermediate results.");
+
+ return tuple_remaining;
+}
+
+/*
+ * copy from src/backend/executor/nodeAgg.c
+ * ExecAggExplainEnd
+ * Called before ExecutorEnd to finish EXPLAIN ANALYZE reporting.
+ */
+static void
+ExecAggExplainEnd(PlanState *planstate, struct StringInfoData *buf)
+{
+ AggState *aggstate = (AggState *)planstate;
+
+ /* Report executor memory used by our memory context. */
+ planstate->instrument->execmemused +=
+ (double)MemoryContextGetPeakSpace(aggstate->aggcontext);
+} /* ExecAggExplainEnd */
+
+/*
+ * ExecAgg - copy from src/backend/executor/nodeAgg.c
+ */
+
+TupleTableSlot *
+ExecVAgg(AggState *node)
+{
+ if (node->agg_done)
+ {
+ ExecEagerFreeAgg(node);
+ return NULL;
+ }
+
+
+ if (((Agg *) node->ss.ps.plan)->aggstrategy == AGG_HASHED)
+ {
+ TupleTableSlot *tuple = NULL;
+ bool streaming = ((Agg *) node->ss.ps.plan)->streaming;
+
+ /*
+ * ExecAgg processing for hashed aggregation -- returns the
+ * next result tuple or NULL. When returning NULL also sets
+ * aggstate to prevent future calls.
+ */
+
+ if (node->hhashtable == NULL)
+ {
+ bool tupremain;
+
+ node->hhashtable = create_agg_hash_table(node);
+ tupremain = agg_hash_initial_1pass(node);
+
+ if ( streaming )
+ {
+ if ( tupremain )
+ node->hhashtable->state = HASHAGG_STREAMING;
+ else
+ node->hhashtable->state = HASHAGG_END_OF_PASSES;
+ }
+ else
+ node->hhashtable->state = HASHAGG_BETWEEN_PASSES;
+ }
+
+
+
+ /* On each call we either return a tuple corresponding to a hash
+ * entry (consuming the entry) or fall through to a state machine
+ * that tries to make additional hash entries available and continue
+ * the loop. (This may result in reaching the "exit" state and
+ * returning a NULL tuple).
+ */
+ for (;;)
+ {
+ if (!node->hhashtable->is_spilling)
+ {
+
+ tuple = agg_retrieve_hash_table(node);
+ node->agg_done = false; /* Not done 'til batches used up. */
+
+ if (tuple != NULL)
+ return tuple;
+ }
+
+ switch (node->hhashtable->state)
+ {
+ case HASHAGG_BETWEEN_PASSES:
+ Assert(!streaming);
+ if (agg_hash_next_pass(node))
+ {
+ node->hhashtable->state = HASHAGG_BETWEEN_PASSES;
+ continue;
+ }
+ node->hhashtable->state = HASHAGG_END_OF_PASSES;
+ /*
+ * pass through. Be sure that the next case statment
+ * is HASHAGG_END_OF_PASSES.
+ */
+
+ case HASHAGG_END_OF_PASSES:
+ node->agg_done = true;
+ if (gp_workfile_caching && node->workfiles_created)
+ {
+ /*
+ * HashAgg closes each spill file after it is done with
+ * them. Since we got here on the regular path, all
+ * files should be closed.
+ */
+ Assert(node->hhashtable->work_set);
+ Assert(node->hhashtable->spill_set == NULL);
+ agg_hash_close_state_file(node->hhashtable);
+ agg_hash_mark_spillset_complete(node);
+ }
+ ExecEagerFreeAgg(node);
+ return NULL;
+
+ case HASHAGG_STREAMING:
+ Assert(streaming);
+ /*expand agg_hash_stream */
+ reset_agg_hash_table(node);
+ if (!agg_hash_initial_1pass(node))
+ node->hhashtable->state = HASHAGG_END_OF_PASSES;
+ continue;
+
+ case HASHAGG_BEFORE_FIRST_PASS:
+ default:
+ elog(ERROR,"hybrid hash aggregation sequencing error");
+ }
+ }
+ }
+ else
+ {
+ return agg_retrieve_direct(node);
+ }
+}
+
+/*
+ * getAggType
+ * Get the aggType for the given Agg node.
+ *
+ * We should really store the type in the Agg struct, and let the planner set the
+ * correct type. As an intermediate step, we compute the type here.
+ */
+static int
+getAggType(Agg *node)
+{
+ int aggType = AggTypeScalar;
+ if (node->numCols > 0 &&
+ (node->lastAgg &&
+ (node->inputHasGrouping && node->numNullCols > 0)))
+ {
+ aggType = AggTypeFinalRollup;
+ }
+ else if (node->numCols > 0 &&
+ (node->inputHasGrouping && node->numNullCols > 0))
+ {
+ aggType = AggTypeIntermediateRollup;
+ }
+ else if (node->numCols > 0)
+ {
+ aggType = AggTypeGroup;
+ }
+ else
+ {
+ insist_log(node->aggstrategy == AGG_PLAIN, "wrong Agg strategy: %d", node->aggstrategy);
+ }
+
+ return aggType;
+}
+
+
+extern Datum ExecEvalVar(ExprState *exprstate, ExprContext *econtext,
+ bool *isNull, ExprDoneCond *isDone);
+
+/*
+ * Copied from src/backend/executor/nodeAgg.c
+ *
+ * We need convert some vectorized tupleDesc to non-vectorzied tupleDesc.
+ */
+AggState *
+VExecInitAgg(Agg *node, EState *estate, int eflags)
+{
+ AggState *aggstate;
+ AggStatePerAgg peragg;
+ Plan *outerPlan;
+ ExprContext *econtext;
+ int numaggs,
+ aggno;
+ ListCell *l;
+ List *nagglist = NULL;
+
+ /* check for unsupported flags */
+ Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));
+
+ /*
+ * create state structure
+ */
+ aggstate = makeNode(AggState);
+ aggstate->ss.ps.plan = (Plan *) node;
+ aggstate->ss.ps.state = estate;
+
+ aggstate->aggs = NIL;
+ aggstate->numaggs = 0;
+ aggstate->eqfunctions = NULL;
+ aggstate->hashfunctions = NULL;
+ aggstate->peragg = NULL;
+ aggstate->agg_done = false;
+ aggstate->pergroup = NULL;
+ aggstate->grp_firstTuple = NULL;
+ aggstate->hashtable = NULL;
+ agg_hash_reset_workfile_state(aggstate);
+
+ /*
+ * Create expression contexts. We need two, one for per-input-tuple
+ * processing and one for per-output-tuple processing. We cheat a little
+ * by using ExecAssignExprContext() to build both.
+ */
+ ExecAssignExprContext(estate, &aggstate->ss.ps);
+ aggstate->tmpcontext = aggstate->ss.ps.ps_ExprContext;
+ ExecAssignExprContext(estate, &aggstate->ss.ps);
+
+ /*
+ * We also need a long-lived memory context for holding hashtable data
+ * structures and transition values. NOTE: the details of what is stored
+ * in aggcontext and what is stored in the regular per-query memory
+ * context are driven by a simple decision: we want to reset the
+ * aggcontext in ExecReScanAgg to recover no-longer-wanted space.
+ */
+ aggstate->aggcontext =
+ AllocSetContextCreate(CurrentMemoryContext,
+ "AggContext",
+ ALLOCSET_DEFAULT_MINSIZE,
+ ALLOCSET_DEFAULT_INITSIZE,
+ ALLOCSET_DEFAULT_MAXSIZE);
+
+#define AGG_NSLOTS 3
+
+ /*
+ * tuple table initialization
+ */
+ aggstate->ss.ss_ScanTupleSlot = ExecInitExtraTupleSlot(estate);
+ ExecInitResultTupleSlot(estate, &aggstate->ss.ps);
+ aggstate->hashslot = ExecInitExtraTupleSlot(estate);
+
+ /*
+ * initialize child expressions
+ *
+ * Note: ExecInitExpr finds Aggrefs for us, and also checks that no aggs
+ * contain other agg calls in their arguments. This would make no sense
+ * under SQL semantics anyway (and it's forbidden by the spec). Because
+ * that is true, we don't need to worry about evaluating the aggs in any
+ * particular order.
+ */
+ /*
+ * if there are aggregate functions in the target list, and the argument
+ * of the aggregate functions are expression(such as operators),when we
+ * initialize the expression, the argument should set to be vectorized
+ * and the result of aggregate functions should set to be non-vectorzied.
+ * we initialize the targetlist two times here, the first time, we get
+ * the non-vectorized target list, then we reset the aggregate in
+ * aggstate and get the vectorized aggregate functions.
+ */
+ /* get the non-vectorized expressions */
+ aggstate->ss.ps.plan->vectorized = false;
+ aggstate->ss.ps.targetlist = (List *)
+ ExecInitExpr((Expr *) node->plan.targetlist,
+ (PlanState *) aggstate);
+ aggstate->ss.ps.plan->vectorized = true;
+
+ /*
+ * reset the aggregate functions,
+ * NOTE: we have to save the aggregate function list,
+ * because the the aggregate functions in the non-vectrozied
+ * target list too
+ */
+ nagglist = aggstate->aggs;
+ aggstate->aggs = NULL;
+ aggstate->numaggs = 0;
+
+ /*
+ * it is the second time to initialize the expression, we don't care
+ * about the result of ExecInitExpr, it is only used to initialize the
+ * vectorized argument of the aggregate functions.
+ */
+ ExecInitExpr((Expr *) node->plan.targetlist,
+ (PlanState *) aggstate);
+
+ aggstate->ss.ps.qual = (List *)
+ ExecInitExpr((Expr *) node->plan.qual,
+ (PlanState *) aggstate);
+
+ /*
+ * CDB: Offer extra info for EXPLAIN ANALYZE.
+ */
+ if (estate->es_instrument)
+ {
+ /* Allocate string buffer. */
+ aggstate->ss.ps.cdbexplainbuf = makeStringInfo();
+
+ /* Request a callback at end of query. */
+ aggstate->ss.ps.cdbexplainfun = ExecAggExplainEnd;
+ }
+
+ /*
+ * initialize child nodes
+ */
+ outerPlan = outerPlan(node);
+ if (IsA(outerPlan, ExternalScan)) {
+ /*
+ * Hack to indicate to PXF when there is an external scan
+ */
+ if (list_length(aggstate->aggs) == 1) {
+ AggrefExprState *aggrefstate = (AggrefExprState *) linitial(aggstate->aggs);
+ Aggref *aggref = (Aggref *) aggrefstate->xprstate.expr;
+ //Only dealing with one agg
+ if (aggref->aggfnoid == COUNT_ANY_OID || aggref->aggfnoid == COUNT_STAR_OID) {
+ eflags |= EXEC_FLAG_EXTERNAL_AGG_COUNT;
+ }
+ }
+ }
+ outerPlanState(aggstate) = ExecInitNode(outerPlan, estate, eflags);
+
+ /*
+ * initialize source tuple type.
+ */
+ ExecAssignScanTypeFromOuterPlan(&aggstate->ss);
+ TupleDesc tdesc = ((ScanState*)aggstate)->ss_ScanTupleSlot->tts_tupleDescriptor;
+ BackportTupleDescriptor((PlanState*)aggstate, tdesc);
+ ExecSetSlotDescriptor(((ScanState*)aggstate)->ss_ScanTupleSlot, tdesc);
+ /*
+ * Initialize result tuple type and projection info.
+ */
+ ExecAssignResultTypeFromTL(&aggstate->ss.ps);
+ TupleDesc ttupDesc = CreateTupleDescCopy(((PlanState*)aggstate)->ps_ResultTupleSlot->tts_tupleDescriptor);
+
+ BackportTupleDescriptor((PlanState*)aggstate, ttupDesc);
+ ExecAssignResultType((PlanState*)aggstate, ttupDesc);
+
+ ExecAssignProjectionInfo(&aggstate->ss.ps, NULL);
+
+ /*
+ * get the count of aggregates in targetlist and quals
+ */
+ numaggs = aggstate->numaggs;
+ Assert(numaggs == list_length(aggstate->aggs) + list_length(aggstate->percs));
+ if (numaggs <= 0)
+ {
+ /*
+ * This is not an error condition: we might be using the Agg node just
+ * to do hash-based grouping. Even in the regular case,
+ * constant-expression simplification could optimize away all of the
+ * Aggrefs in the targetlist and qual. So keep going, but force local
+ * copy of numaggs positive so that palloc()s below don't choke.
+ */
+ numaggs = 1;
+ }
+
+ /*
+ * If we are grouping, precompute fmgr lookup data for inner loop. We need
+ * both equality and hashing functions to do it by hashing, but only
+ * equality if not hashing.
+ */
+ if (node->numCols > 0)
+ {
+ TupleDesc desc = ExecGetScanType(&aggstate->ss);
+ desc = CreateTupleDescCopy(desc);
+ BackportTupleDescriptor((PlanState*)aggstate, desc);
+
+ if (node->aggstrategy == AGG_HASHED)
+ {
+ execTuplesHashPrepare(desc,
+ node->numCols,
+ node->grpColIdx,
+ &aggstate->eqfunctions,
+ &aggstate->hashfunctions);
+ }
+ else
+ aggstate->eqfunctions =
+ execTuplesMatchPrepare(desc,
+ node->numCols,
+ node->grpColIdx);
+ }
+
+ /*
+ * Set up aggregate-result storage in the output expr context, and also
+ * allocate my private per-agg working storage
+ */
+ econtext = aggstate->ss.ps.ps_ExprContext;
+ econtext->ecxt_aggvalues = (Datum *) palloc0(sizeof(Datum) * numaggs);
+ econtext->ecxt_aggnulls = (bool *) palloc0(sizeof(bool) * numaggs);
+
+ peragg = (AggStatePerAgg) palloc0(sizeof(AggStatePerAggData) * numaggs);
+ aggstate->peragg = peragg;
+
+ if (node->aggstrategy == AGG_HASHED)
+ {
+ aggstate->hash_needed = get_agg_hash_collist(aggstate);
+ }
+ else
+ {
+ AggStatePerGroup pergroup;
+
+ pergroup = (AggStatePerGroup) palloc0(sizeof(AggStatePerGroupData) * numaggs);
+ aggstate->pergroup = pergroup;
+ }
+
+ /*
+ * set the NO of aggregate functions, it is used in the non-vectorzied
+ * target list.
+ */
+ aggno = -1;
+ foreach(l, nagglist)
+ {
+ AggrefExprState *aggrefstate = (AggrefExprState *) lfirst(l);
+ Aggref *aggref = (Aggref *) aggrefstate->xprstate.expr;
+ AggStatePerAgg peraggstate;
+ int i;
+
+ /* Planner should have assigned aggregate to correct level */
+ Assert(aggref->agglevelsup == 0);
+
+ /* Look for a previous duplicate aggregate */
+ for (i = 0; i <= aggno; i++)
+ {
+ if (equal(aggref, peragg[i].aggref) &&
+ !contain_volatile_functions((Node *) aggref))
+ break;
+ }
+ if (i <= aggno)
+ {
+ /* Found a match to an existing entry, so just mark it */
+ aggrefstate->aggno = i;
+ continue;
+ }
+
+ /* Nope, so assign a new PerAgg record */
+ peragg[++aggno].aggref = aggref;
+
+ /* Mark Aggref state node with assigned index in the result array */
+ aggrefstate->aggno = aggno;
+ }
+
+ /*
+ * Perform lookups of aggregate function info, and initialize the
+ * unchanging fields of the per-agg data. We also detect duplicate
+ * aggregates (for example, "SELECT sum(x) ... HAVING sum(x) > 0"). When
+ * duplicates are detected, we only make an AggStatePerAgg struct for the
+ * first one. The clones are simply pointed at the same result entry by
+ * giving them duplicate aggno values.
+ */
+ aggno = -1;
+ foreach(l, aggstate->aggs)
+ {
+ AggrefExprState *aggrefstate = (AggrefExprState *) lfirst(l);
+ Aggref *aggref = (Aggref *) aggrefstate->xprstate.expr;
+ AggStatePerAgg peraggstate;
+ List *inputTargets = NIL;
+ List *inputSortClauses = NIL;
+ Oid *inputTypes = NULL;
+ int numInputs;
+ int numArguments;
+ int numSortCols;
+ List *sortlist;
+ HeapTuple aggTuple;
+ Form_pg_aggregate aggform;
+ Oid aggtranstype;
+ AclResult aclresult;
+ Oid transfn_oid = InvalidOid,
+ finalfn_oid = InvalidOid;
+ Expr *transfnexpr,
+ *finalfnexpr,
+ *prelimfnexpr;
+ Datum textInitVal;
+ int i;
+ ListCell *lc;
+ cqContext *pcqCtx;
+
+ /* Planner should have assigned aggregate to correct level */
+ Assert(aggref->agglevelsup == 0);
+
+ /* Look for a previous duplicate aggregate */
+ for (i = 0; i <= aggno; i++)
+ {
+ if (equal(aggref, peragg[i].aggref) &&
+ !contain_volatile_functions((Node *) aggref))
+ break;
+ }
+ if (i <= aggno)
+ {
+ /* Found a match to an existing entry, so just mark it */
+ aggrefstate->aggno = i;
+ continue;
+ }
+
+ /* Nope, so assign a new PerAgg record */
+ peraggstate = &peragg[++aggno];
+
+ /* Mark Aggref state node with assigned index in the result array */
+ aggrefstate->aggno = aggno;
+
+ /* Fill in the peraggstate data */
+ peraggstate->aggrefstate = aggrefstate;
+ peraggstate->aggref = aggref;
+ numArguments = list_length(aggref->args);
+ peraggstate->numArguments = numArguments;
+
+ /*
+ * Use these information from ExecInitExpr for per agg info.
+ */
+ inputTargets = aggrefstate->inputTargets;
+ inputSortClauses = aggrefstate->inputSortClauses;
+ numInputs = list_length(inputTargets);
+ numSortCols = list_length(inputSortClauses);
+
+ peraggstate->numSortCols = numSortCols;
+ peraggstate->numInputs = numInputs;
+
+ /* MPP has some restrictions. */
+ Assert(!(aggref->aggdistinct && aggref->aggorder));
+ Assert(numArguments == 1 || !aggref->aggdistinct);
+
+ /* Get actual datatypes of the inputs. These could be different from
+ * the agg's declared input types, when the agg accepts ANY, ANYARRAY
+ * or ANYELEMENT. The result will have argument types at 0 through
+ * numArguments-1 and sort key types mixed in or at numArguments through
+ * numInputs.
+ */
+ inputTypes = (Oid*)palloc0(sizeof(Oid)*(numInputs));
+ i = 0;
+ foreach(lc, inputTargets)
+ {
+ TargetEntry *tle = (TargetEntry *) lfirst(lc);
+ inputTypes[i++] = exprType((Node*)tle->expr);
+ }
+
+ pcqCtx = caql_beginscan(
+ NULL,
+ cql("SELECT * FROM pg_aggregate "
+ " WHERE aggfnoid = :1 ",
+ ObjectIdGetDatum(aggref->aggfnoid)));
+
+ aggTuple = caql_getnext(pcqCtx);
+
+ if (!HeapTupleIsValid(aggTuple))
+ elog(ERROR, "cache lookup failed for aggregate %u",
+ aggref->aggfnoid);
+ aggform = (Form_pg_aggregate) GETSTRUCT(aggTuple);
+
+ /* Check permission to call aggregate function */
+ aclresult = pg_proc_aclcheck(aggref->aggfnoid, GetUserId(),
+ ACL_EXECUTE);
+ if (aclresult != ACLCHECK_OK)
+ aclcheck_error(aclresult, ACL_KIND_PROC,
+ get_func_name(aggref->aggfnoid));
+
+ switch ( aggref->aggstage) /* MPP */
+ {
+ case AGGSTAGE_NORMAL: /* Single-stage aggregation */
+ peraggstate->transfn_oid = transfn_oid = aggform->aggtransfn;
+ peraggstate->finalfn_oid = finalfn_oid = aggform->aggfinalfn;
+ break;
+
+ case AGGSTAGE_PARTIAL:/* Two-stage aggregation -- preliminary stage */
+ /* the perliminary stage for two-stage aggregation */
+ peraggstate->transfn_oid = transfn_oid = aggform->aggtransfn;
+ peraggstate->finalfn_oid = finalfn_oid = InvalidOid;
+ break;
+
+ case AGGSTAGE_INTERMEDIATE:
+ peraggstate->transfn_oid = transfn_oid = aggform->aggprelimfn;
+ peraggstate->finalfn_oid = finalfn_oid = InvalidOid;
+ break;
+
+ case AGGSTAGE_FINAL: /* Two-stage aggregation - final stage */
+ peraggstate->transfn_oid = transfn_oid = aggform->aggprelimfn;
+ peraggstate->finalfn_oid = finalfn_oid = aggform->aggfinalfn;
+ break;
+ }
+
+ peraggstate->prelimfn_oid = aggform->aggprelimfn;
+
+ /* Check that aggregate owner has permission to call component fns */
+ {
+ Oid aggOwner;
+ int fetchCount;
+
+ aggOwner = caql_getoid_plus(
+ NULL,
+ &fetchCount,
+ NULL,
+ cql("SELECT proowner FROM pg_proc "
+ " WHERE oid = :1 ",
+ ObjectIdGetDatum(aggref->aggfnoid)));
+
+ if (!fetchCount)
+ elog(ERROR, "cache lookup failed for function %u",
+ aggref->aggfnoid);
+
+ aclresult = pg_proc_aclcheck(transfn_oid, aggOwner,
+ ACL_EXECUTE);
+ if (aclresult != ACLCHECK_OK)
+ aclcheck_error(aclresult, ACL_KIND_PROC,
+ get_func_name(transfn_oid));
+ if (OidIsValid(finalfn_oid))
+ {
+ aclresult = pg_proc_aclcheck(finalfn_oid, aggOwner,
+ ACL_EXECUTE);
+ if (aclresult != ACLCHECK_OK)
+ aclcheck_error(aclresult, ACL_KIND_PROC,
+ get_func_name(finalfn_oid));
+ }
+ if (OidIsValid(peraggstate->prelimfn_oid))
+ {
+ aclresult = pg_proc_aclcheck(peraggstate->prelimfn_oid, aggOwner,
+ ACL_EXECUTE);
+ if (aclresult != ACLCHECK_OK)
+ aclcheck_error(aclresult, ACL_KIND_PROC,
+ get_func_name(peraggstate->prelimfn_oid));
+ }
+ }
+
+ /* check if the transition type is polymorphic and if so resolve it */
+ aggtranstype = resolve_polymorphic_transtype(aggform->aggtranstype,
+ aggref->aggfnoid,
+ inputTypes);
+
+ /* build expression trees using actual argument & result types */
+ build_aggregate_fnexprs(inputTypes,
+ numArguments,
+ aggtranstype,
+ aggref->aggtype,
+ transfn_oid,
+ finalfn_oid,
+ InvalidOid /* prelim */,
+ InvalidOid /* invtrans */,
+ InvalidOid /* invprelim */,
+ &transfnexpr,
+ &finalfnexpr,
+ &prelimfnexpr,
+ NULL,
+ NULL);
+
+ fmgr_info(transfn_oid, &peraggstate->transfn);
+ peraggstate->transfn.fn_expr = (Node *) transfnexpr;
+
+ if (OidIsValid(finalfn_oid))
+ {
+ fmgr_info(finalfn_oid, &peraggstate->finalfn);
+ peraggstate->finalfn.fn_expr = (Node *) finalfnexpr;
+ }
+
+ if (OidIsValid(peraggstate->prelimfn_oid))
+ {
+ fmgr_info(peraggstate->prelimfn_oid, &peraggstate->prelimfn);
+ peraggstate->prelimfn.fn_expr = (Node *) prelimfnexpr;
+ }
+
+ get_typlenbyval(aggref->aggtype,
+ &peraggstate->resulttypeLen,
+ &peraggstate->resulttypeByVal);
+ get_typlenbyval(aggtranstype,
+ &peraggstate->transtypeLen,
+ &peraggstate->transtypeByVal);
+
+ /*
+ * initval is potentially null, so don't try to access it as a struct
+ * field. Must do it the hard way with caql_getattr
+ */
+ textInitVal = caql_getattr(pcqCtx,
+ Anum_pg_aggregate_agginitval,
+ &peraggstate->initValueIsNull);
+
+ if (peraggstate->initValueIsNull)
+ peraggstate->initValue = (Datum) 0;
+ else
+ peraggstate->initValue = GetAggInitVal(textInitVal,
+ aggtranstype);
+
+ /*
+ * If the transfn is strict and the initval is NULL, make sure input
+ * type and transtype are the same (or at least binary-compatible), so
+ * that it's OK to use the first input value as the initial
+ * transValue. This should have been checked at agg definition time,
+ * but just in case...
+ */
+ if (peraggstate->transfn.fn_strict && peraggstate->initValueIsNull)
+ {
+ if (numArguments < 1 ||
+ !IsBinaryCoercible(inputTypes[0], aggtranstype))
+ ereport(ERROR,
+ (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
+ errmsg("aggregate %u needs to have compatible input type and transition type",
+ aggref->aggfnoid)));
+ }
+
+ /*
+ * Get a tupledesc corresponding to the inputs (including sort
+ * expressions) of the agg.
+ */
+ peraggstate->evaldesc = ExecTypeFromTL(inputTargets, false);
+
+ /* Create slot we're going to do argument evaluation in */
+ peraggstate->evalslot = ExecInitExtraTupleSlot(estate);
+ ExecSetSlotDescriptor(peraggstate->evalslot, peraggstate->evaldesc);
+
+ /* Set up projection info for evaluation */
+ peraggstate->evalproj = ExecBuildProjectionInfo(aggrefstate->args,
+ aggstate->tmpcontext,
+ peraggstate->evalslot,
+ NULL);
+
+ /*
+ * If we're doing either DISTINCT or ORDER BY, then we have a list of
+ * SortGroupClause nodes; fish out the data in them and stick them
+ * into arrays.
+ *
+ * Note that by construction, if there is a DISTINCT clause then the
+ * ORDER BY clause is a prefix of it (see transformDistinctClause).
+ */
+ if (aggref->aggdistinct)
+ {
+ TargetEntry *tle;
+ SortClause *sc;
+ Oid eq_function;
+
+ /*
+ * GPDB 4 doesh't implement DISTINCT aggs for aggs having more than
+ * than one argument, nor does it allow an ordered aggregate to
+ * specify distinct, but PG 9 does. The SQL standard allows the
+ * one-arg-for-DISTINCT restriction, but we really we ought to
+ * implement it the way PG 9 does eventually.
+ *
+ * For now we use the scalar equalfn field of AggStatePerAggData
+ * for DQAs instead of treating DQAs more generally.
+ */
+ if (numArguments != 1)
+ ereport(ERROR,
+ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ errmsg("DISTINCT is supported only for single-argument aggregates")));
+
+ eq_function = equality_oper_funcid(inputTypes[0]);
+ fmgr_info(eq_function, &(peraggstate->equalfn));
+
+ tle = (TargetEntry*)linitial(inputTargets);
+ tle->ressortgroupref = 1;
+
+ sc = makeNode(SortClause);
+ sc->tleSortGroupRef = tle->ressortgroupref;
+ sc->sortop = ordering_oper_opid(inputTypes[0]);
+
+ sortlist = list_make1(sc);
+ numSortCols = 1;
+ }
+ else if ( aggref->aggorder )
+ {
+ sortlist = aggref->aggorder->sortClause;
+ numSortCols = list_length(sortlist);
+ }
+ else
+ {
+ sortlist = NULL;
+ numSortCols = 0;
+ }
+
+
+ peraggstate->numSortCols = numSortCols;
+
+ if (numSortCols > 0)
+ {
+ /*
+ * We don't implement DISTINCT or ORDER BY aggs in the HASHED case
+ * (yet)
+ */
+ Assert(node->aggstrategy != AGG_HASHED);
+
+ /* If we have only one input, we need its len/byval info. */
+ if (numInputs == 1)
+ {
+ get_typlenbyval(inputTypes[0],
+ &peraggstate->inputtypeLen,
+ &peraggstate->inputtypeByVal);
+ }
+
+ /* Extract the sort information for use later */
+ peraggstate->sortColIdx =
+ (AttrNumber *) palloc(numSortCols * sizeof(AttrNumber));
+ peraggstate->sortOperators =
+ (Oid *) palloc(numSortCols * sizeof(Oid));
+
+ i = 0;
+ foreach(lc, sortlist)
+ {
+ SortClause *sortcl = (SortClause *) lfirst(lc);
+ TargetEntry *tle = get_sortgroupclause_tle(sortcl,
+ inputTargets);
+
+ /* the parser should have made sure of this */
+ Assert(OidIsValid(sortcl->sortop));
+
+ peraggstate->sortColIdx[i] = tle->resno;
+ peraggstate->sortOperators[i] = sortcl->sortop;
+ i++;
+ }
+ Assert(i == numSortCols);
+ }
+
+ if (aggref->aggdistinct)
+ {
+ Oid eqfunc;
+
+ Assert(numArguments == 1);
+ Assert(numSortCols == 1);
+
+ /*
+ * We need the equal function for the DISTINCT comparison we will
+ * make.
+ */
+ eqfunc = equality_oper_funcid(inputTypes[0]);
+ fmgr_info(eqfunc, &peraggstate->equalfn);
+ }
+
+ caql_endscan(pcqCtx);
+ }
+
+ /*
+ * Process percentile expressions. These are treated separately from
+ * Aggref expressions at the moment as we cannot change the catalog, but
+ * this will be incorporated into the existing Agggref architecture
+ * when we can change the catalog. The operation for percentile functions
+ * is very similar to the Aggref operation except that there is no
+ * function oid for transition function. We manually manupilate
+ * FmgrInfo without the oid.
+ * In case the Agg handles PercentileExpr, there shouldn't be Aggref
+ * in conjunction with PercentileExpr in the target list (and havingQual),
+ * or vice versa, from the current design of percentile functions.
+ * However, we don't assert anything to keep that assumption, for the
+ * later extensibility.
+ */
+ foreach (l, aggstate->percs)
+ {
+ PercentileExprState *percstate = (PercentileExprState *) lfirst(l);
+ PercentileExpr *perc = (PercentileExpr *) percstate->xprstate.expr;
+ AggStatePerAgg peraggstate;
+ FmgrInfo *transfn;
+ int numArguments;
+ int i;
+ Oid trans_argtypes[FUNC_MAX_ARGS];
+ ListCell *lc;
+ Expr *dummy_expr;
+
+ /* Look for a previous duplicate aggregate */
+ for (i = 0; i <= aggno; i++)
+ {
+ /*
+ * In practice, percentile expression doesn't contain
+ * volatile functions since everything is evaluated and
+ * becomes Var during the preprocess such as ordering operations.
+ * However, adding a check for volatile may be robust and
+ * consistent with Aggref initialization.
+ */
+ if (equal(perc, peragg[i].perc) &&
+ !contain_volatile_functions((Node *) perc))
+ break;
+ }
+ if (i <= aggno)
+ {
+ /* Found a match to an existing entry, so just mark it */
+ percstate->aggno = i;
+ continue;
+ }
+
+ /* Nope, so assign a new PerAgg record */
+ peraggstate = &peragg[++aggno];
+
+ /* Mark Aggref state node with assigned index in the result array */
+ percstate->aggno = aggno;
+
+ /* Fill in the peraggstate data */
+ peraggstate->percstate = percstate;
+ peraggstate->perc = perc;
+ /*
+ * numArguments = arg + ORDER BY + pc + tc
+ * See notes on percentile_cont_trans() and ExecInitExpr() for
+ * PercentileExpr.
+ */
+ numArguments = list_length(perc->args) + list_length(perc->sortClause) + 2;
+ peraggstate->numArguments = numArguments;
+
+ /*
+ * Set up transfn. In general, we should use fmgr_info, but we don't
+ * have the catalog function (thus no oid for functions) due to the
+ * difficulity of changing the catalog at the moment. This should
+ * be cleaned when we can change the catalog.
+ */
+ transfn = &peraggstate->transfn;
+ transfn->fn_nargs = list_length(perc->args) + 1;
+ transfn->fn_strict = false;
+ transfn->fn_retset = false;
+ transfn->fn_mcxt = CurrentMemoryContext;
+ transfn->fn_addr = perc->perckind == PERC_DISC ?
+ percentile_disc_trans : percentile_cont_trans;
+ transfn->fn_oid = InvalidOid;
+
+ /*
+ * trans type is the same as result type, as they don't have final func.
+ */
+ trans_argtypes[0] = perc->perctype;
+ i = 1;
+ /*
+ * Literal arguments.
+ */
+ foreach (lc, perc->args)
+ {
+ Node *arg = lfirst(lc);
+ trans_argtypes[i++] = exprType(arg);
+ }
+ /*
+ * ORDER BY arguments.
+ */
+ foreach (lc, perc->sortTargets)
+ {
+ TargetEntry *tle = lfirst(lc);
+ trans_argtypes[i++] = exprType((Node *) tle->expr);
+ }
+ /*
+ * Peer count and total count.
+ */
+ trans_argtypes[i++] = INT8OID;
+ trans_argtypes[i++] = INT8OID;
+ /*
+ * Build FuncExpr for the transition function.
+ */
+ build_aggregate_fnexprs(trans_argtypes,
+ i,
+ perc->perctype,
+ perc->perctype,
+ InvalidOid,
+ InvalidOid,
+ InvalidOid,
+ InvalidOid,
+ InvalidOid,
+ (Expr **) &transfn->fn_expr,
+ &dummy_expr, NULL, NULL, NULL);
+
+ get_typlenbyval(perc->perctype,
+ &peraggstate->resulttypeLen,
+ &peraggstate->resulttypeByVal);
+ get_typlenbyval(perc->perctype,
+ &peraggstate->transtypeLen,
+ &peraggstate->transtypeByVal);
+
+ /*
+ * Hard code for the known information.
+ */
+ peraggstate->initValueIsNull = true;
+ peraggstate->initValue = (Datum) 0;
+
+ peraggstate->finalfn_oid = InvalidOid;
+ peraggstate->prelimfn_oid = InvalidOid;
+
+ /*
+ * Get a tupledesc corresponding to the inputs (including sort
+ * expressions) of the agg.
+ */
+ peraggstate->evaldesc = ExecTypeFromTL(percstate->tlist, false);
+
+ /* Create slot we're going to do argument evaluation in */
+ peraggstate->evalslot = ExecInitExtraTupleSlot(estate);
+ ExecSetSlotDescriptor(peraggstate->evalslot, peraggstate->evaldesc);
+
+ /* Set up projection info for evaluation */
+ peraggstate->evalproj = ExecBuildProjectionInfo(percstate->args,
+ aggstate->tmpcontext,
+ peraggstate->evalslot,
+ NULL);
+ }
+
+ /* Update numaggs to match number of unique aggregates found */
+ aggstate->numaggs = aggno + 1;
+
+ /* MPP */
+ aggstate->hhashtable = NULL;
+
+ /* ROLLUP */
+ aggstate->perpassthru = NULL;
+
+ if (node->inputHasGrouping)
+ {
+ AggStatePerGroup perpassthru;
+
+ perpassthru = (AggStatePerGroup) palloc0(sizeof(AggStatePerGroupData) * numaggs);
+ aggstate->perpassthru = perpassthru;
+
+ }
+
+ aggstate->num_attrs = 0;
+
+ aggstate->aggType = getAggType(node);
+
+ /* Set the default memory manager */
+ aggstate->mem_manager.alloc = cxt_alloc;
+ aggstate->mem_manager.free = cxt_free;
+ aggstate->mem_manager.manager = aggstate->aggcontext;
+ aggstate->mem_manager.realloc_ratio = 1;
+
+ initGpmonPktForAgg((Plan *)node, &aggstate->ss.ps.gpmon_pkt, estate);
+
+ return aggstate;
+}
+
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/ce2814d4/contrib/vexecutor/vagg.h
----------------------------------------------------------------------
diff --git a/contrib/vexecutor/vagg.h b/contrib/vexecutor/vagg.h
new file mode 100644
index 0000000..cf08082
--- /dev/null
+++ b/contrib/vexecutor/vagg.h
@@ -0,0 +1,92 @@
+#ifndef VAGG_H
+#define VAGG_H
+
+#include "executor/execHHashagg.h"
+
+/* batch hashagg group linklist header */
+typedef struct GroupData {
+ HashAggEntry *entry; /* pointer to agg_hash_entry */
+ int idx; /* index of idx_list */
+} GroupData;
+
+/* batch hashagg group data */
+typedef struct BatchAggGroupData{
+ GroupData *group_header; /* group linklist header */
+
+ int group_idx; /* current group header index */
+ int group_cnt; /* group header count */
+
+ /*
+ * linklist elements
+ * each item's index is the index to columnData.
+ * each item's value is the next pointer, -1 is the end of a linklist.
+ */
+ int *idx_list;
+}BatchAggGroupData;
+
+/* it is copyed from src/backend/utils/adt/numeric.c */
+typedef struct IntFloatAvgTransdata
+{
+ int32 _len; /* len for varattrib, do not touch directly */
+#if 1
+ int32 pad; /* pad so int64 and float64 will be 8 bytes aligned */
+#endif
+
+ int64 count;
+ float8 sum;
+} IntFloatAvgTransdata;
+
+/*
+ * the first args typs of vectorized aggregate functions is used as a Datum,
+ * so we can encapsulate the old transdata in the VectorizedAggData, and
+ * convert the VectorizedAggData to be a Datum, then the grouping information
+ * and skip information can be transfer in the aggregate functions.
+ */
+typedef struct VectorizedAggData
+{
+ int32 _len; /* len for varattrib, do not touch directly */
+#if 1
+ int32 pad; /* pad so int64 and float64 will be 8 bytes aligned */
+#endif
+
+ /* grouping information */
+ BatchAggGroupData *groupData;
+
+ /* old data */
+ Datum data;
+ bool isnull;
+ bool isnovalue;
+ bool isalloc;
+
+ /* skip information */
+ bool *skip;
+ int nrows;
+}VectorizedAggData;
+
+#define _VACCUM_NUMERIC_HEADER(type) \
+Datum v##type##_accum(PG_FUNCTION_ARGS);
+
+#define _VAVG_NUMERIC_HEADER(type) \
+Datum v##type##_avg_accum(PG_FUNCTION_ARGS);
+
+#define _VINC_NUMERIC_HEADER(type) \
+Datum v##type##_inc(PG_FUNCTION_ARGS);
+
+#define VACCUM_NUMERIC_HEADER(type) \
+ _VACCUM_NUMERIC_HEADER(type) \
+ _VAVG_NUMERIC_HEADER(type) \
+ _VINC_NUMERIC_HEADER(type)
+
+VACCUM_NUMERIC_HEADER(int2)
+VACCUM_NUMERIC_HEADER(int4)
+VACCUM_NUMERIC_HEADER(int8)
+VACCUM_NUMERIC_HEADER(float4)
+VACCUM_NUMERIC_HEADER(float8)
+
+extern Datum vec_inc_any(PG_FUNCTION_ARGS);
+
+extern TupleTableSlot * ExecVAgg(AggState *node);
+extern AggState * VExecInitAgg(Agg *node, EState *estate, int eflags);
+extern VectorizedAggData * InitAggVectorizedData(AggState *aggstate);
+
+#endif
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/ce2814d4/contrib/vexecutor/vcheck.c
----------------------------------------------------------------------
diff --git a/contrib/vexecutor/vcheck.c b/contrib/vexecutor/vcheck.c
index 788cc19..c0d6d41 100644
--- a/contrib/vexecutor/vcheck.c
+++ b/contrib/vexecutor/vcheck.c
@@ -21,6 +21,7 @@
#include "access/htup.h"
#include "catalog/catquery.h"
#include "catalog/pg_operator.h"
+#include "catalog/pg_proc.h"
#include "cdb/cdbappendonlyam.h"
#include "cdb/cdbllize.h"
#include "parser/parse_oper.h"
@@ -59,6 +60,86 @@ typedef struct VectorizedContext
bool replace;
}VectorizedContext;
+static Oid get_aggregate_oid(const char *aggname, Oid oidType);
+static char *getProcNameOnlyFromOid(Oid object_oid);
+
+// copyed from src/backend/utils/cache/lsyscache.c
+// Get oid of aggregate with given name and argument type
+static Oid
+get_aggregate_oid(const char *aggname, Oid oidType)
+{
+ HeapTuple htup = NULL;
+
+ // lookup pg_proc for functions with the given name and arg type
+ cqContext *pcqCtx = caql_beginscan(
+ NULL,
+ cql("SELECT * FROM pg_proc "
+ " WHERE proname = :1",
+ PointerGetDatum((char *) aggname)));
+
+ Oid oidResult = InvalidOid;
+ while (HeapTupleIsValid(htup = caql_getnext(pcqCtx)))
+ {
+ Oid oidProc = HeapTupleGetOid(htup);
+
+ Form_pg_proc proctuple = (Form_pg_proc) GETSTRUCT(htup);
+
+ // skip functions with the wrong number of type of arguments
+ if (0 != proctuple->pronargs && InvalidOid != oidType)
+ {
+ if (1 != proctuple->pronargs || oidType != proctuple->proargtypes.values[0])
+ {
+ continue;
+ }
+ }
+ else if((0 != proctuple->pronargs && InvalidOid == oidType) ||
+ (0 == proctuple->pronargs && InvalidOid != oidType))
+ continue;
+
+ if (caql_getcount(
+ NULL,
+ cql("SELECT COUNT(*) FROM pg_aggregate "
+ " WHERE aggfnoid = :1 ",
+ ObjectIdGetDatum(oidProc))) > 0)
+ {
+ oidResult = oidProc;
+ break;
+ }
+ }
+
+ caql_endscan(pcqCtx);
+
+ return oidResult;
+}
+
+//copied from src/backend/catalog/aclchk.c and we refactor it.
+static char *
+getProcNameOnlyFromOid(Oid object_oid)
+{
+ StringInfoData tname;
+ initStringInfo(&tname);
+ HeapTuple tup;
+ cqContext *pCtx;
+
+ Assert(OidIsValid(object_oid));
+
+ pCtx = caql_beginscan(
+ NULL,
+ cql("SELECT * FROM pg_proc "
+ " WHERE oid = :1 ",
+ ObjectIdGetDatum(object_oid)));
+
+ tup = caql_getnext(pCtx);
+ if (!HeapTupleIsValid(tup))
+ elog(ERROR, "oid [%u] not found in table pg_class", object_oid);
+
+ appendStringInfo(&tname, "%s", NameStr(((Form_pg_proc)GETSTRUCT(tup))->proname));
+
+ caql_endscan(pCtx);
+ return tname.data;
+}
+
+
/*
* Check all the expressions if they can be vectorized
* NOTE: if an expressions is vectorized, we return false...,because we should check
@@ -129,7 +210,7 @@ CheckVectorizedExpression(Node *node, VectorizedContext *ctx)
//get the vectorized operator functions
//NOTE:we have no ParseState now, Give the NULL value is OK but not good...
tuple = oper(NULL, list_make1(makeString(get_opname(op->opno))),
- ltype, rtype, false, -1);
+ ltype, rtype, true, -1);
if(NULL == tuple)
return true;
@@ -152,6 +233,72 @@ CheckVectorizedExpression(Node *node, VectorizedContext *ctx)
return false;
}
+ /* support aggregate functions */
+ if(IsA(node, Aggref))
+ {
+ Aggref *ref = (Aggref*)node;
+ char *aggname = NULL;
+ Oid retType;
+ Oid vaggoid;
+
+ if(ref->aggdistinct || NULL != ref->aggorder)
+ return true;
+
+ /* Make sure there is less than one arguments */
+ if(1 < list_length(ref->args))
+ return true;
+
+ /* check arguments */
+ if(NULL != ref->args)
+ {
+ if(CheckVectorizedExpression(linitial(ref->args), ctx))
+ return true;
+ retType = ctx->retType;
+ }
+ else
+ retType = InvalidOid;
+
+ /* check the vectorized aggregate functions */
+ aggname = getProcNameOnlyFromOid(ref->aggfnoid);
+
+ if(0 == strcmp(aggname, "count") &&
+ 0 == list_length(ref->args))
+ aggname = "veccount";
+
+ Assert(NUll != aggname);
+
+ vaggoid = get_aggregate_oid(aggname, retType);
+ if(InvalidOid == vaggoid)
+ return true;
+
+ if(ctx->replace)
+ ref->aggfnoid = vaggoid;
+
+ return false;
+ }
+
+ /*
+ * if there are const in expressions, it may need to convert
+ * type implicitly by FuncExpr, we only check if the arguments
+ * of the FuncExpr is constant.
+ */
+ if(IsA(node, FuncExpr))
+ {
+ FuncExpr *f = (FuncExpr*)node;
+ ListCell *l = NULL;
+ Node* expr = NULL;
+
+ if(1 < list_length(f->args))
+ return true;
+
+ expr = (Node*)linitial(f->args);
+ if(!IsA(expr, Const))
+ return true;
+
+ ctx->retType = f->funcresulttype;
+ return false;
+ }
+
//now, other nodes treat as can not be vectorized
return plan_tree_walker(node, CheckVectorizedExpression, ctx);;
}
@@ -175,6 +322,25 @@ CheckPlanNodeWalker(PlannerInfo *root, Plan *plan)
return true;
}
+ /* if sub node can not vectorized, set the parent cannot vectorized too */
+ if( (NULL != plan->lefttree && !plan->lefttree->vectorized) ||
+ (NULL != plan->righttree && !plan->righttree->vectorized))
+ {
+ plan->vectorized = false;
+ return true;
+ }
+
+ /* the result of aggregate functions is scalar */
+ if(IsA(plan, Motion) && IsA((plan->lefttree), Agg))
+ {
+ plan->vectorized = false;
+ return true;
+ }
+
+ /* Don't support SORT Aggregate so far */
+ if(IsA(plan, Agg) && ((Agg*)plan)->aggstrategy == AGG_SORTED)
+ return true;
+
planner_init_plan_tree_base(&ctx.base, root);
ctx.replace =false;
@@ -253,7 +419,11 @@ ReplacePlanVectorzied(PlannerInfo *root, Plan *plan)
Plan*
CheckAndReplacePlanVectorized(PlannerInfo *root, Plan *plan)
{
+ /* the top plan node can not be vectorized so far */
+ plan->vectorized = false;
plan = CheckPlanVectorzied(root, plan);
+ Assert(!plan->vectorized);
+ plan->vectorized = false;
return ReplacePlanVectorzied(root, plan);
}
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/ce2814d4/contrib/vexecutor/vcheck.h
----------------------------------------------------------------------
diff --git a/contrib/vexecutor/vcheck.h b/contrib/vexecutor/vcheck.h
index ee4eba6..d31e72a 100644
--- a/contrib/vexecutor/vcheck.h
+++ b/contrib/vexecutor/vcheck.h
@@ -35,7 +35,16 @@ typedef struct VectorizedState
{
bool vectorized;
PlanState *parent;
+
+ /* for table scan */
aoinfo *ao;
+
+ /* for aggregate */
+ void *transdata;
+ TupleTableSlot **aggslot;
+ BatchAggGroupData *batchGroupData;
+ GroupData *groupData;
+ int *indexList;
}VectorizedState;
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/ce2814d4/contrib/vexecutor/vexecutor.c
----------------------------------------------------------------------
diff --git a/contrib/vexecutor/vexecutor.c b/contrib/vexecutor/vexecutor.c
index 1694fac..ffc588e 100644
--- a/contrib/vexecutor/vexecutor.c
+++ b/contrib/vexecutor/vexecutor.c
@@ -23,14 +23,17 @@
#include "vcheck.h"
#include "miscadmin.h"
#include "tuplebatch.h"
+#include "executor/nodeAgg.h"
#include "executor/nodeTableScan.h"
#include "catalog/catquery.h"
#include "cdb/cdbvars.h"
+#include "nodes/execnodes.h"
#include "utils/memaccounting.h"
#include "execVScan.h"
#include "execVQual.h"
#include "vexecutor.h"
#include "nodeVMotion.h"
+#include "vagg.h"
PG_MODULE_MAGIC;
int BATCHSIZE = 1024;
@@ -41,7 +44,7 @@ static int MAXBATCHSIZE = 4096;
*/
static PlanState* VExecInitNode(Plan *node,EState *eState,int eflags);
static PlanState* VExecVecNode(PlanState *Node, PlanState *parentNode, EState *eState,int eflags);
-static TupleTableSlot* VExecProcNode(PlanState *node,TupleTableSlot** pRtr);
+static bool VExecProcNode(PlanState *node,TupleTableSlot** pRtr);
static bool VExecEndNode(PlanState *node);
extern int currentSliceId;
@@ -99,7 +102,7 @@ _PG_fini(void)
* Backport the TupleDesc information to normal type. Due to Vectorized type unrecognizable in normal execution node,
* the TupleDesc structure should backport metadata to normal type before we do V->N result pop up.
*/
-static void backportTupleDescriptor(PlanState* ps,TupleDesc td)
+void BackportTupleDescriptor(PlanState* ps,TupleDesc td)
{
cqContext *pcqCtx;
HeapTuple tuple;
@@ -109,6 +112,8 @@ static void backportTupleDescriptor(PlanState* ps,TupleDesc td)
{
oidtypeid = GetNtype(td->attrs[i]->atttypid);
+ Assert(InvalidOid != oidtypeid);
+
pcqCtx = caql_beginscan(
NULL,
cql("SELECT * FROM pg_type "
@@ -116,8 +121,12 @@ static void backportTupleDescriptor(PlanState* ps,TupleDesc td)
ObjectIdGetDatum(oidtypeid)));
tuple = caql_getnext(pcqCtx);
+ /*
+ * the tuple descriptor of Agg node could be {vtype, vtype, ntype, ntype},
+ * we should convert the vtype to ntype and skip the ntype which alreay exists.
+ */
if (!HeapTupleIsValid(tuple))
- elog(ERROR, "cache lookup failed for type %u", oidtypeid);
+ continue;
typeForm = (Form_pg_type) GETSTRUCT(tuple);
td->attrs[i]->atttypid = oidtypeid;
@@ -128,21 +137,99 @@ static void backportTupleDescriptor(PlanState* ps,TupleDesc td)
caql_endscan(pcqCtx);
}
-
- ExecAssignResultType(ps,td);
}
static PlanState* VExecInitNode(Plan *node,EState *eState,int eflags)
{
elog(DEBUG3, "PG VEXECINIT NODE");
- return NULL;
+ PlanState *state = NULL;
+
+ if(NULL == node)
+ return NULL;
+
+ switch (nodeTag(node) )
+ {
+ case T_Agg:
+ state = VExecInitAgg(node, eState, eflags);
+ break;
+ default:
+ break;
+ }
+
+ return state;
}
#define HAS_EXECUTOR_MEMORY_ACCOUNT(planNode, NodeType) \
(NULL != planNode->memoryAccount && \
MEMORY_OWNER_TYPE_Exec_##NodeType == planNode->memoryAccount->ownerType)
+static void
+VExecVecTableScan(PlanState *node, PlanState *parentNode, EState *eState,int eflags)
+{
+ TupleDesc td = ((TableScanState *)node)->ss.ss_ScanTupleSlot->tts_tupleDescriptor;
+ ((TableScanState *)node)->ss.ss_ScanTupleSlot->PRIVATE_tb = PointerGetDatum(tbGenerate(td->natts,BATCHSIZE));
+ node->ps_ResultTupleSlot->PRIVATE_tb = PointerGetDatum(tbGenerate(td->natts,BATCHSIZE));
+
+ /* if V->N */
+ if( NULL == parentNode ||
+ NULL == parentNode->vectorized ||
+ !((VectorizedState *)parentNode->vectorized)->vectorized)
+ {
+ BackportTupleDescriptor(node,node->ps_ResultTupleSlot->tts_tupleDescriptor);
+ ExecAssignResultType(node, node->ps_ResultTupleSlot->tts_tupleDescriptor);
+ }
+
+ return;
+}
+
+static void
+VExecVecAgg(PlanState *node, PlanState *parentNode, EState *eState,int eflags)
+{
+ int aggno;
+ VectorizedState *vstate;
+ AggState *aggstate = (AggState*)node;
+ for (aggno = 0; aggno < aggstate->numaggs; aggno++)
+ {
+ AggStatePerAgg peraggstate = &aggstate->peragg[aggno];
+ TupleDesc td = peraggstate->evalslot->tts_tupleDescriptor;
+ peraggstate->evalslot->PRIVATE_tb = PointerGetDatum(tbGenerate(td->natts,BATCHSIZE));
+ }
+
+ Assert(NULL != node->vectorized);
+ vstate = (VectorizedState*)node->vectorized;
+ vstate->transdata = InitAggVectorizedData(aggstate);
+ vstate->aggslot = (TupleTableSlot**)palloc0(sizeof(TupleTableSlot*) * aggstate->numaggs);
+
+ vstate->batchGroupData = (BatchAggGroupData*)palloc0(sizeof(BatchAggGroupData));
+ vstate->groupData = (GroupData*)palloc0(sizeof(GroupData) * BATCHSIZE);
+ vstate->indexList = (int*)palloc0(sizeof(int) * BATCHSIZE);
+
+ return;
+}
+
+static void
+VExecVecMotion(PlanState *node, PlanState *parentNode, EState *eState,int eflags)
+{
+ Plan *plan = node->plan;
+
+ Assert(NULL != plan);
+
+ if( NULL == parentNode ||
+ NULL == parentNode->vectorized ||
+ ((Motion*)plan)->sendSorted ||
+ ((Motion*)plan)->motionType == MOTIONTYPE_HASH ||
+ !((VectorizedState *)parentNode->vectorized)->vectorized)
+ {
+ ((VectorizedState *)node->vectorized)->vectorized = false;
+ plan->vectorized = false;
+ }
+ else
+ {
+ ((VectorizedState *)node->vectorized)->vectorized = true;
+ }
+}
+
/*
* when vectorized_executor_enable is ON, we have to process the plan.
*/
@@ -163,43 +250,49 @@ VExecVecNode(PlanState *node, PlanState *parentNode, EState *eState,int eflags)
vstate->vectorized = plan->vectorized;
vstate->parent = parentNode;
- if(Gp_role != GP_ROLE_DISPATCH)
+ switch (nodeTag(node) )
{
- switch (nodeTag(node) )
- {
- case T_AppendOnlyScan:
- case T_ParquetScan:
- case T_TableScanState:
- if(HAS_EXECUTOR_MEMORY_ACCOUNT(plan, TableScan))
+ case T_AppendOnlyScan:
+ case T_ParquetScan:
+ case T_TableScanState:
+ if(Gp_role != GP_ROLE_DISPATCH)
+ {
+ if(HAS_EXECUTOR_MEMORY_ACCOUNT(plan, Agg))
+ {
START_MEMORY_ACCOUNT(plan->memoryAccount);
-
- TupleDesc td = ((TableScanState *)node)->ss.ss_ScanTupleSlot->tts_tupleDescriptor;
- ((TableScanState *)node)->ss.ss_ScanTupleSlot->PRIVATE_tb = PointerGetDatum(tbGenerate(td->natts,BATCHSIZE));
- node->ps_ResultTupleSlot->PRIVATE_tb = PointerGetDatum(tbGenerate(td->natts,BATCHSIZE));
-
- /* if V->N */
- if( NULL == parentNode ||
- NULL == parentNode->vectorized ||
- !((VectorizedState *)parentNode->vectorized)->vectorized)
- backportTupleDescriptor(node,node->ps_ResultTupleSlot->tts_tupleDescriptor);
-
- if(HAS_EXECUTOR_MEMORY_ACCOUNT(plan, TableScan))
+ VExecVecTableScan(node, parentNode, eState, eflags);
+ END_MEMORY_ACCOUNT();
+ }
+ else
+ VExecVecTableScan(node, parentNode, eState, eflags);
+ }
+ break;
+ case T_AggState:
+ if(Gp_role != GP_ROLE_DISPATCH)
+ {
+ if(HAS_EXECUTOR_MEMORY_ACCOUNT(plan, Agg))
+ {
+ START_MEMORY_ACCOUNT(plan->memoryAccount);
+ VExecVecAgg(node, parentNode, eState, eflags);
END_MEMORY_ACCOUNT();
- break;
- case T_MotionState:
- if( NULL == parentNode ||
- NULL == parentNode->vectorized ||
- ((Motion*)plan)->sendSorted ||
- ((Motion*)plan)->motionType == MOTIONTYPE_HASH ||
- !((VectorizedState *)parentNode->vectorized)->vectorized)
- ((VectorizedState *)node->vectorized)->vectorized = false;
+ }
else
- ((VectorizedState *)node->vectorized)->vectorized = true;
- break;
- default:
- ((VectorizedState *)node->vectorized)->vectorized = false;
- break;
- }
+ VExecVecAgg(node, parentNode, eState, eflags);
+ }
+ break;
+ case T_MotionState:
+ if(HAS_EXECUTOR_MEMORY_ACCOUNT(plan, Agg))
+ {
+ START_MEMORY_ACCOUNT(plan->memoryAccount);
+ VExecVecMotion(node, parentNode, eState, eflags);
+ END_MEMORY_ACCOUNT();
+ }
+ else
+ VExecVecMotion(node, parentNode, eState, eflags);
+ break;
+ default:
+ ((VectorizedState *)node->vectorized)->vectorized = false;
+ break;
}
/* recursively */
@@ -211,7 +304,7 @@ VExecVecNode(PlanState *node, PlanState *parentNode, EState *eState,int eflags)
return node;
}
-static TupleTableSlot* VExecProcNode(PlanState *node,TupleTableSlot** pRtr)
+static bool VExecProcNode(PlanState *node,TupleTableSlot** pRtr)
{
if(!((VectorizedState*)node->vectorized)->vectorized)
return false;
@@ -225,6 +318,9 @@ static TupleTableSlot* VExecProcNode(PlanState *node,TupleTableSlot** pRtr)
case T_TableScanState:
result = ExecTableVScanVirtualLayer((TableScanState*)node);
break;
+ case T_AggState:
+ result = ExecVAgg((AggState*)node);
+ break;
case T_MotionState:
result = ExecVMotionVirtualLayer((MotionState*)node);
break;
@@ -267,6 +363,8 @@ HasVecExecOprator(NodeTag tag)
{
case T_AppendOnlyScan:
case T_ParquetScan:
+ case T_Agg:
+ case T_Motion:
result = true;
break;
default:
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/ce2814d4/contrib/vexecutor/vexecutor.h
----------------------------------------------------------------------
diff --git a/contrib/vexecutor/vexecutor.h b/contrib/vexecutor/vexecutor.h
index bb2f267..a050245 100644
--- a/contrib/vexecutor/vexecutor.h
+++ b/contrib/vexecutor/vexecutor.h
@@ -25,11 +25,13 @@
#include "executor/executor.h"
#include "vtype.h"
#include "vtype_ext.h"
+#include "vagg.h"
/* Function declarations for extension loading and unloading */
extern void _PG_init(void);
extern void _PG_fini(void);
extern bool HasVecExecOprator(NodeTag tag);
+extern void BackportTupleDescriptor(PlanState* ps,TupleDesc td);
#endif
[2/9] incubator-hawq git commit: HAWQ-1612. Implement vectorized
aggregate functions, such as avg/sum/count.
Posted by rl...@apache.org.
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/ce2814d4/src/test/feature/vexecutor/ans/vagg.ans
----------------------------------------------------------------------
diff --git a/src/test/feature/vexecutor/ans/vagg.ans b/src/test/feature/vexecutor/ans/vagg.ans
new file mode 100644
index 0000000..817119e
--- /dev/null
+++ b/src/test/feature/vexecutor/ans/vagg.ans
@@ -0,0 +1,1672 @@
+-- start_ignore
+SET SEARCH_PATH=TestVexecutor_vagg;
+SET
+-- end_ignore
+select avg(a), count(b), sum(c), count(*) from test_int2;
+ avg | count | sum | count
+-----+-------+-----+-------
+ 8.5 | 16 | 32 | 17
+(1 row)
+
+select avg(a), count(b), sum(c), count(*) from test_int4;
+ avg | count | sum | count
+-----+-------+-----+-------
+ 8.5 | 16 | 32 | 17
+(1 row)
+
+select avg(a), count(b), sum(c), count(*) from test_int8;
+ avg | count | sum | count
+-----+-------+-----+-------
+ 8.5 | 16 | 32 | 17
+(1 row)
+
+select avg(a), count(b), sum(c), count(*) from test_float4;
+ avg | count | sum | count
+-----+-------+-----+-------
+ 8.5 | 16 | 32 | 17
+(1 row)
+
+select avg(a), count(b), sum(c), count(*) from test_float8;
+ avg | count | sum | count
+-----+-------+-----+-------
+ 8.5 | 16 | 32 | 17
+(1 row)
+
+select avg(a), count(b), sum(c), count(*) from test_int2 where a > 65536 and b > 0;
+ avg | count | sum | count
+-----+-------+-----+-------
+ | 0 | | 0
+(1 row)
+
+select avg(a), count(b), sum(c), count(*) from test_int4 where a > 65536 and b > 0;
+ avg | count | sum | count
+-----+-------+-----+-------
+ | 0 | | 0
+(1 row)
+
+select avg(a), count(b), sum(c), count(*) from test_int8 where a > 65536 and b > 0;
+ avg | count | sum | count
+-----+-------+-----+-------
+ | 0 | | 0
+(1 row)
+
+select avg(a), count(b), sum(c), count(*) from test_float4 where a > 65536 and b > 0;
+ avg | count | sum | count
+-----+-------+-----+-------
+ | 0 | | 0
+(1 row)
+
+select avg(a), count(b), sum(c), count(*) from test_float8 where a > 65536 and b > 0;
+ avg | count | sum | count
+-----+-------+-----+-------
+ | 0 | | 0
+(1 row)
+
+select avg(a), count(b), sum(c), count(*) from test_int2 where a > 5120 and b > 0;
+ avg | count | sum | count
+-----+-------+-----+-------
+ | 0 | | 0
+(1 row)
+
+select avg(a), count(b), sum(c), count(*) from test_int4 where a > 5120 and b > 0;
+ avg | count | sum | count
+-----+-------+-----+-------
+ | 0 | | 0
+(1 row)
+
+select avg(a), count(b), sum(c), count(*) from test_int8 where a > 5120 and b > 0;
+ avg | count | sum | count
+-----+-------+-----+-------
+ | 0 | | 0
+(1 row)
+
+select avg(a), count(b), sum(c), count(*) from test_float4 where a > 5120 and b > 0;
+ avg | count | sum | count
+-----+-------+-----+-------
+ | 0 | | 0
+(1 row)
+
+select avg(a), count(b), sum(c), count(*) from test_float8 where a > 5120 and b > 0;
+ avg | count | sum | count
+-----+-------+-----+-------
+ | 0 | | 0
+(1 row)
+
+select avg(a), count(b), sum(c), count(*) from test_int2 where a > 5120 and b > 0;
+ avg | count | sum | count
+-----+-------+-----+-------
+ | 0 | | 0
+(1 row)
+
+select avg(a), count(b), sum(c), count(*) from test_int4 where a > 5120 and b > 0;
+ avg | count | sum | count
+-----+-------+-----+-------
+ | 0 | | 0
+(1 row)
+
+select avg(a), count(b), sum(c), count(*) from test_int8 where a > 5120 and b > 0;
+ avg | count | sum | count
+-----+-------+-----+-------
+ | 0 | | 0
+(1 row)
+
+select avg(a), count(b), sum(c), count(*) from test_float4 where a > 5120 and b > 0;
+ avg | count | sum | count
+-----+-------+-----+-------
+ | 0 | | 0
+(1 row)
+
+select avg(a), count(b), sum(c), count(*) from test_float8 where a > 5120 and b > 0;
+ avg | count | sum | count
+-----+-------+-----+-------
+ | 0 | | 0
+(1 row)
+
+select avg(a), count(b), sum(c), count(*) from test_int2;
+ avg | count | sum | count
+-----+-------+-----+-------
+ 8.5 | 16 | 32 | 17
+(1 row)
+
+select avg(a), count(b), sum(c), count(*) from test_int4;
+ avg | count | sum | count
+-----+-------+-----+-------
+ 8.5 | 16 | 32 | 17
+(1 row)
+
+select avg(a), count(b), sum(c), count(*) from test_int8;
+ avg | count | sum | count
+-----+-------+-----+-------
+ 8.5 | 16 | 32 | 17
+(1 row)
+
+select avg(a), count(b), sum(c), count(*) from test_float4;
+ avg | count | sum | count
+-----+-------+-----+-------
+ 8.5 | 16 | 32 | 17
+(1 row)
+
+select avg(a), count(b), sum(c), count(*) from test_float8;
+ avg | count | sum | count
+-----+-------+-----+-------
+ 8.5 | 16 | 32 | 17
+(1 row)
+
+select avg(a) from test_int2;
+ avg
+-----
+ 8.5
+(1 row)
+
+select avg(a) from test_int4;
+ avg
+-----
+ 8.5
+(1 row)
+
+select avg(a) from test_int8;
+ avg
+-----
+ 8.5
+(1 row)
+
+select avg(a) from test_float4;
+ avg
+-----
+ 8.5
+(1 row)
+
+select avg(a) from test_float8;
+ avg
+-----
+ 8.5
+(1 row)
+
+select avg(a) from test_int2 where a > 5120 and b > 0;
+ avg
+-----
+
+(1 row)
+
+select avg(a) from test_int4 where a > 5120 and b > 0;
+ avg
+-----
+
+(1 row)
+
+select avg(a) from test_int8 where a > 5120 and b > 0;
+ avg
+-----
+
+(1 row)
+
+select avg(a) from test_float4 where a > 5120 and b > 0;
+ avg
+-----
+
+(1 row)
+
+select avg(a) from test_float8 where a > 5120 and b > 0;
+ avg
+-----
+
+(1 row)
+
+select sum(a) from test_int2;
+ sum
+-----
+ 136
+(1 row)
+
+select sum(a) from test_int4;
+ sum
+-----
+ 136
+(1 row)
+
+select sum(a) from test_int8;
+ sum
+-----
+ 136
+(1 row)
+
+select sum(a) from test_float4;
+ sum
+-----
+ 136
+(1 row)
+
+select sum(a) from test_float8;
+ sum
+-----
+ 136
+(1 row)
+
+select sum(a) from test_int2 where a > 5120 and b > 0;
+ sum
+-----
+
+(1 row)
+
+select sum(a) from test_int4 where a > 5120 and b > 0;
+ sum
+-----
+
+(1 row)
+
+select sum(a) from test_int8 where a > 5120 and b > 0;
+ sum
+-----
+
+(1 row)
+
+select sum(a) from test_float4 where a > 5120 and b > 0;
+ sum
+-----
+
+(1 row)
+
+select sum(a) from test_float8 where a > 5120 and b > 0;
+ sum
+-----
+
+(1 row)
+
+select count(a) from test_int2;
+ count
+-------
+ 16
+(1 row)
+
+select count(a) from test_int4;
+ count
+-------
+ 16
+(1 row)
+
+select count(a) from test_int8;
+ count
+-------
+ 16
+(1 row)
+
+select count(a) from test_float4;
+ count
+-------
+ 16
+(1 row)
+
+select count(a) from test_float8;
+ count
+-------
+ 16
+(1 row)
+
+select count(a) from test_int2 where a > 5120 and b > 0;
+ count
+-------
+ 0
+(1 row)
+
+select count(a) from test_int4 where a > 5120 and b > 0;
+ count
+-------
+ 0
+(1 row)
+
+select count(a) from test_int8 where a > 5120 and b > 0;
+ count
+-------
+ 0
+(1 row)
+
+select count(a) from test_float4 where a > 5120 and b > 0;
+ count
+-------
+ 0
+(1 row)
+
+select count(a) from test_float8 where a > 5120 and b > 0;
+ count
+-------
+ 0
+(1 row)
+
+select count(*) from test_int2;
+ count
+-------
+ 17
+(1 row)
+
+select count(*) from test_int4;
+ count
+-------
+ 17
+(1 row)
+
+select count(*) from test_int8;
+ count
+-------
+ 17
+(1 row)
+
+select count(*) from test_float4;
+ count
+-------
+ 17
+(1 row)
+
+select count(*) from test_float8;
+ count
+-------
+ 17
+(1 row)
+
+select count(*) from test_int2 where a > 5120 and b > 0;
+ count
+-------
+ 0
+(1 row)
+
+select count(*) from test_int4 where a > 5120 and b > 0;
+ count
+-------
+ 0
+(1 row)
+
+select count(*) from test_int8 where a > 5120 and b > 0;
+ count
+-------
+ 0
+(1 row)
+
+select count(*) from test_float4 where a > 5120 and b > 0;
+ count
+-------
+ 0
+(1 row)
+
+select count(*) from test_float8 where a > 5120 and b > 0;
+ count
+-------
+ 0
+(1 row)
+
+--group by a;
+select avg(a), count(b), sum(c), count(*) from test_int2 where a > 5120 and b > 0 group by a order by a;
+ avg | count | sum | count
+-----+-------+-----+-------
+(0 rows)
+
+select avg(a), count(b), sum(c), count(*) from test_int4 where a > 5120 and b > 0 group by a order by a;
+ avg | count | sum | count
+-----+-------+-----+-------
+(0 rows)
+
+select avg(a), count(b), sum(c), count(*) from test_int8 where a > 5120 and b > 0 group by a order by a;
+ avg | count | sum | count
+-----+-------+-----+-------
+(0 rows)
+
+select avg(a), count(b), sum(c), count(*) from test_float4 where a > 5120 and b > 0 group by a order by a;
+ avg | count | sum | count
+-----+-------+-----+-------
+(0 rows)
+
+select avg(a), count(b), sum(c), count(*) from test_float8 where a > 5120 and b > 0 group by a order by a;
+ avg | count | sum | count
+-----+-------+-----+-------
+(0 rows)
+
+select avg(a), count(b), sum(c), count(*) from test_int2 group by a order by a;
+ avg | count | sum | count
+-----+-------+-----+-------
+ 1 | 1 | 2 | 1
+ 2 | 1 | 2 | 1
+ 3 | 1 | 2 | 1
+ 4 | 1 | 2 | 1
+ 5 | 1 | 2 | 1
+ 6 | 1 | 2 | 1
+ 7 | 1 | 2 | 1
+ 8 | 1 | 2 | 1
+ 9 | 1 | 2 | 1
+ 10 | 1 | 2 | 1
+ 11 | 1 | 2 | 1
+ 12 | 1 | 2 | 1
+ 13 | 1 | 2 | 1
+ 14 | 1 | 2 | 1
+ 15 | 1 | 2 | 1
+ 16 | 1 | 2 | 1
+ | 0 | | 1
+(17 rows)
+
+select avg(a), count(b), sum(c), count(*) from test_int4 group by a order by a;
+ avg | count | sum | count
+-----+-------+-----+-------
+ 1 | 1 | 2 | 1
+ 2 | 1 | 2 | 1
+ 3 | 1 | 2 | 1
+ 4 | 1 | 2 | 1
+ 5 | 1 | 2 | 1
+ 6 | 1 | 2 | 1
+ 7 | 1 | 2 | 1
+ 8 | 1 | 2 | 1
+ 9 | 1 | 2 | 1
+ 10 | 1 | 2 | 1
+ 11 | 1 | 2 | 1
+ 12 | 1 | 2 | 1
+ 13 | 1 | 2 | 1
+ 14 | 1 | 2 | 1
+ 15 | 1 | 2 | 1
+ 16 | 1 | 2 | 1
+ | 0 | | 1
+(17 rows)
+
+select avg(a), count(b), sum(c), count(*) from test_int8 group by a order by a;
+ avg | count | sum | count
+-----+-------+-----+-------
+ 1 | 1 | 2 | 1
+ 2 | 1 | 2 | 1
+ 3 | 1 | 2 | 1
+ 4 | 1 | 2 | 1
+ 5 | 1 | 2 | 1
+ 6 | 1 | 2 | 1
+ 7 | 1 | 2 | 1
+ 8 | 1 | 2 | 1
+ 9 | 1 | 2 | 1
+ 10 | 1 | 2 | 1
+ 11 | 1 | 2 | 1
+ 12 | 1 | 2 | 1
+ 13 | 1 | 2 | 1
+ 14 | 1 | 2 | 1
+ 15 | 1 | 2 | 1
+ 16 | 1 | 2 | 1
+ | 0 | | 1
+(17 rows)
+
+select avg(a), count(b), sum(c), count(*) from test_float4 group by a order by a;
+ avg | count | sum | count
+-----+-------+-----+-------
+ 1 | 1 | 2 | 1
+ 2 | 1 | 2 | 1
+ 3 | 1 | 2 | 1
+ 4 | 1 | 2 | 1
+ 5 | 1 | 2 | 1
+ 6 | 1 | 2 | 1
+ 7 | 1 | 2 | 1
+ 8 | 1 | 2 | 1
+ 9 | 1 | 2 | 1
+ 10 | 1 | 2 | 1
+ 11 | 1 | 2 | 1
+ 12 | 1 | 2 | 1
+ 13 | 1 | 2 | 1
+ 14 | 1 | 2 | 1
+ 15 | 1 | 2 | 1
+ 16 | 1 | 2 | 1
+ | 0 | | 1
+(17 rows)
+
+select avg(a), count(b), sum(c), count(*) from test_float8 group by a order by a;
+ avg | count | sum | count
+-----+-------+-----+-------
+ 1 | 1 | 2 | 1
+ 2 | 1 | 2 | 1
+ 3 | 1 | 2 | 1
+ 4 | 1 | 2 | 1
+ 5 | 1 | 2 | 1
+ 6 | 1 | 2 | 1
+ 7 | 1 | 2 | 1
+ 8 | 1 | 2 | 1
+ 9 | 1 | 2 | 1
+ 10 | 1 | 2 | 1
+ 11 | 1 | 2 | 1
+ 12 | 1 | 2 | 1
+ 13 | 1 | 2 | 1
+ 14 | 1 | 2 | 1
+ 15 | 1 | 2 | 1
+ 16 | 1 | 2 | 1
+ | 0 | | 1
+(17 rows)
+
+select avg(a) from test_int2 group by a order by a;
+ avg
+-----
+ 1
+ 2
+ 3
+ 4
+ 5
+ 6
+ 7
+ 8
+ 9
+ 10
+ 11
+ 12
+ 13
+ 14
+ 15
+ 16
+
+(17 rows)
+
+select avg(a) from test_int4 group by a order by a;
+ avg
+-----
+ 1
+ 2
+ 3
+ 4
+ 5
+ 6
+ 7
+ 8
+ 9
+ 10
+ 11
+ 12
+ 13
+ 14
+ 15
+ 16
+
+(17 rows)
+
+select avg(a) from test_int8 group by a order by a;
+ avg
+-----
+ 1
+ 2
+ 3
+ 4
+ 5
+ 6
+ 7
+ 8
+ 9
+ 10
+ 11
+ 12
+ 13
+ 14
+ 15
+ 16
+
+(17 rows)
+
+select avg(a) from test_float4 group by a order by a;
+ avg
+-----
+ 1
+ 2
+ 3
+ 4
+ 5
+ 6
+ 7
+ 8
+ 9
+ 10
+ 11
+ 12
+ 13
+ 14
+ 15
+ 16
+
+(17 rows)
+
+select avg(a) from test_float8 group by a order by a;
+ avg
+-----
+ 1
+ 2
+ 3
+ 4
+ 5
+ 6
+ 7
+ 8
+ 9
+ 10
+ 11
+ 12
+ 13
+ 14
+ 15
+ 16
+
+(17 rows)
+
+select avg(a) from test_int2 where a > 5120 and b > 0 group by a order by a;
+ avg
+-----
+(0 rows)
+
+select avg(a) from test_int4 where a > 5120 and b > 0 group by a order by a;
+ avg
+-----
+(0 rows)
+
+select avg(a) from test_int8 where a > 5120 and b > 0 group by a order by a;
+ avg
+-----
+(0 rows)
+
+select avg(a) from test_float4 where a > 5120 and b > 0 group by a order by a;
+ avg
+-----
+(0 rows)
+
+select avg(a) from test_float8 where a > 5120 and b > 0 group by a order by a;
+ avg
+-----
+(0 rows)
+
+select sum(a) from test_int2 group by a order by a;
+ sum
+-----
+ 1
+ 2
+ 3
+ 4
+ 5
+ 6
+ 7
+ 8
+ 9
+ 10
+ 11
+ 12
+ 13
+ 14
+ 15
+ 16
+
+(17 rows)
+
+select sum(a) from test_int4 group by a order by a;
+ sum
+-----
+ 1
+ 2
+ 3
+ 4
+ 5
+ 6
+ 7
+ 8
+ 9
+ 10
+ 11
+ 12
+ 13
+ 14
+ 15
+ 16
+
+(17 rows)
+
+select sum(a) from test_int8 group by a order by a;
+ sum
+-----
+ 1
+ 2
+ 3
+ 4
+ 5
+ 6
+ 7
+ 8
+ 9
+ 10
+ 11
+ 12
+ 13
+ 14
+ 15
+ 16
+
+(17 rows)
+
+select sum(a) from test_float4 group by a order by a;
+ sum
+-----
+ 1
+ 2
+ 3
+ 4
+ 5
+ 6
+ 7
+ 8
+ 9
+ 10
+ 11
+ 12
+ 13
+ 14
+ 15
+ 16
+
+(17 rows)
+
+select sum(a) from test_float8 group by a order by a;
+ sum
+-----
+ 1
+ 2
+ 3
+ 4
+ 5
+ 6
+ 7
+ 8
+ 9
+ 10
+ 11
+ 12
+ 13
+ 14
+ 15
+ 16
+
+(17 rows)
+
+select sum(a) from test_int2 where a > 5120 and b > 0 group by a order by a;
+ sum
+-----
+(0 rows)
+
+select sum(a) from test_int4 where a > 5120 and b > 0 group by a order by a;
+ sum
+-----
+(0 rows)
+
+select sum(a) from test_int8 where a > 5120 and b > 0 group by a order by a;
+ sum
+-----
+(0 rows)
+
+select sum(a) from test_float4 where a > 5120 and b > 0 group by a order by a;
+ sum
+-----
+(0 rows)
+
+select sum(a) from test_float8 where a > 5120 and b > 0 group by a order by a;
+ sum
+-----
+(0 rows)
+
+select count(a) from test_int2 group by a;
+ count
+-------
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 0
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+(17 rows)
+
+select count(a) from test_int4 group by a;
+ count
+-------
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 0
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+(17 rows)
+
+select count(a) from test_int8 group by a;
+ count
+-------
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 0
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+(17 rows)
+
+select count(a) from test_float4 group by a;
+ count
+-------
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 0
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+(17 rows)
+
+select count(a) from test_float8 group by a;
+ count
+-------
+ 1
+ 1
+ 1
+ 1
+ 1
+ 0
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+(17 rows)
+
+select count(a) from test_int2 where a > 5120 and b > 0 group by a;
+ count
+-------
+(0 rows)
+
+select count(a) from test_int4 where a > 5120 and b > 0 group by a;
+ count
+-------
+(0 rows)
+
+select count(a) from test_int8 where a > 5120 and b > 0 group by a;
+ count
+-------
+(0 rows)
+
+select count(a) from test_float4 where a > 5120 and b > 0 group by a;
+ count
+-------
+(0 rows)
+
+select count(a) from test_float8 where a > 5120 and b > 0 group by a;
+ count
+-------
+(0 rows)
+
+select count(*) from test_int2 group by a;
+ count
+-------
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+(17 rows)
+
+select count(*) from test_int4 group by a;
+ count
+-------
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+(17 rows)
+
+select count(*) from test_int8 group by a;
+ count
+-------
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+(17 rows)
+
+select count(*) from test_float4 group by a;
+ count
+-------
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+(17 rows)
+
+select count(*) from test_float8 group by a;
+ count
+-------
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+ 1
+(17 rows)
+
+select count(*) from test_int2 where a > 5120 and b > 0 group by a;
+ count
+-------
+(0 rows)
+
+select count(*) from test_int4 where a > 5120 and b > 0 group by a;
+ count
+-------
+(0 rows)
+
+select count(*) from test_int8 where a > 5120 and b > 0 group by a;
+ count
+-------
+(0 rows)
+
+select count(*) from test_float4 where a > 5120 and b > 0 group by a;
+ count
+-------
+(0 rows)
+
+select count(*) from test_float8 where a > 5120 and b > 0 group by a;
+ count
+-------
+(0 rows)
+
+--group by b;
+select avg(a), count(b), sum(c), count(*) from test_int2 where a > 5120 and b > 0 group by b;
+ avg | count | sum | count
+-----+-------+-----+-------
+(0 rows)
+
+select avg(a), count(b), sum(c), count(*) from test_int4 where a > 5120 and b > 0 group by b;
+ avg | count | sum | count
+-----+-------+-----+-------
+(0 rows)
+
+select avg(a), count(b), sum(c), count(*) from test_int8 where a > 5120 and b > 0 group by b;
+ avg | count | sum | count
+-----+-------+-----+-------
+(0 rows)
+
+select avg(a), count(b), sum(c), count(*) from test_float4 where a > 5120 and b > 0 group by b;
+ avg | count | sum | count
+-----+-------+-----+-------
+(0 rows)
+
+select avg(a), count(b), sum(c), count(*) from test_float8 where a > 5120 and b > 0 group by b;
+ avg | count | sum | count
+-----+-------+-----+-------
+(0 rows)
+
+select avg(a), count(b), sum(c), count(*) from test_int2 group by b;
+ avg | count | sum | count
+-----+-------+-----+-------
+ 8.5 | 16 | 32 | 16
+ | 0 | | 1
+(2 rows)
+
+select avg(a), count(b), sum(c), count(*) from test_int4 group by b;
+ avg | count | sum | count
+-----+-------+-----+-------
+ 8.5 | 16 | 32 | 16
+ | 0 | | 1
+(2 rows)
+
+select avg(a), count(b), sum(c), count(*) from test_int8 group by b;
+ avg | count | sum | count
+-----+-------+-----+-------
+ | 0 | | 1
+ 8.5 | 16 | 32 | 16
+(2 rows)
+
+select avg(a), count(b), sum(c), count(*) from test_float4 group by b;
+ avg | count | sum | count
+-----+-------+-----+-------
+ 8.5 | 16 | 32 | 16
+ | 0 | | 1
+(2 rows)
+
+select avg(a), count(b), sum(c), count(*) from test_float8 group by b;
+ avg | count | sum | count
+-----+-------+-----+-------
+ | 0 | | 1
+ 8.5 | 16 | 32 | 16
+(2 rows)
+
+select avg(a) from test_int2 group by b;
+ avg
+-----
+ 8.5
+
+(2 rows)
+
+select avg(a) from test_int4 group by b;
+ avg
+-----
+ 8.5
+
+(2 rows)
+
+select avg(a) from test_int8 group by b;
+ avg
+-----
+ 8.5
+
+(2 rows)
+
+select avg(a) from test_float4 group by b;
+ avg
+-----
+ 8.5
+
+(2 rows)
+
+select avg(a) from test_float8 group by b;
+ avg
+-----
+
+ 8.5
+(2 rows)
+
+select avg(a) from test_int2 where a > 5120 and b > 0 group by b;
+ avg
+-----
+(0 rows)
+
+select avg(a) from test_int4 where a > 5120 and b > 0 group by b;
+ avg
+-----
+(0 rows)
+
+select avg(a) from test_int8 where a > 5120 and b > 0 group by b;
+ avg
+-----
+(0 rows)
+
+select avg(a) from test_float4 where a > 5120 and b > 0 group by b;
+ avg
+-----
+(0 rows)
+
+select avg(a) from test_float8 where a > 5120 and b > 0 group by b;
+ avg
+-----
+(0 rows)
+
+select sum(a) from test_int2 group by b;
+ sum
+-----
+
+ 136
+(2 rows)
+
+select sum(a) from test_int4 group by b;
+ sum
+-----
+
+ 136
+(2 rows)
+
+select sum(a) from test_int8 group by b;
+ sum
+-----
+ 136
+
+(2 rows)
+
+select sum(a) from test_float4 group by b;
+ sum
+-----
+ 136
+
+(2 rows)
+
+select sum(a) from test_float8 group by b;
+ sum
+-----
+
+ 136
+(2 rows)
+
+select sum(a) from test_int2 where a > 5120 and b > 0 group by b;
+ sum
+-----
+(0 rows)
+
+select sum(a) from test_int4 where a > 5120 and b > 0 group by b;
+ sum
+-----
+(0 rows)
+
+select sum(a) from test_int8 where a > 5120 and b > 0 group by b;
+ sum
+-----
+(0 rows)
+
+select sum(a) from test_float4 where a > 5120 and b > 0 group by b;
+ sum
+-----
+(0 rows)
+
+select sum(a) from test_float8 where a > 5120 and b > 0 group by b;
+ sum
+-----
+(0 rows)
+
+select count(a) from test_int2 group by b;
+ count
+-------
+ 0
+ 16
+(2 rows)
+
+select count(a) from test_int4 group by b;
+ count
+-------
+ 0
+ 16
+(2 rows)
+
+select count(a) from test_int8 group by b;
+ count
+-------
+ 0
+ 16
+(2 rows)
+
+select count(a) from test_float4 group by b;
+ count
+-------
+ 16
+ 0
+(2 rows)
+
+select count(a) from test_float8 group by b;
+ count
+-------
+ 0
+ 16
+(2 rows)
+
+select count(a) from test_int2 where a > 5120 and b > 0 group by b;
+ count
+-------
+(0 rows)
+
+select count(a) from test_int4 where a > 5120 and b > 0 group by b;
+ count
+-------
+(0 rows)
+
+select count(a) from test_int8 where a > 5120 and b > 0 group by b;
+ count
+-------
+(0 rows)
+
+select count(a) from test_float4 where a > 5120 and b > 0 group by b;
+ count
+-------
+(0 rows)
+
+select count(a) from test_float8 where a > 5120 and b > 0 group by b;
+ count
+-------
+(0 rows)
+
+select count(*) from test_int2 group by b;
+ count
+-------
+ 1
+ 16
+(2 rows)
+
+select count(*) from test_int4 group by b;
+ count
+-------
+ 1
+ 16
+(2 rows)
+
+select count(*) from test_int8 group by b;
+ count
+-------
+ 1
+ 16
+(2 rows)
+
+select count(*) from test_float4 group by b;
+ count
+-------
+ 16
+ 1
+(2 rows)
+
+select count(*) from test_float8 group by b;
+ count
+-------
+ 1
+ 16
+(2 rows)
+
+select count(*) from test_int2 where a > 5120 and b > 0 group by b;
+ count
+-------
+(0 rows)
+
+select count(*) from test_int4 where a > 5120 and b > 0 group by b;
+ count
+-------
+(0 rows)
+
+select count(*) from test_int8 where a > 5120 and b > 0 group by b;
+ count
+-------
+(0 rows)
+
+select count(*) from test_float4 where a > 5120 and b > 0 group by b;
+ count
+-------
+(0 rows)
+
+select count(*) from test_float8 where a > 5120 and b > 0 group by b;
+ count
+-------
+(0 rows)
+
+--group by b,c;
+select avg(a), count(b), sum(c), count(*) from test_int2 where a > 5120 and b > 0 group by b,c;
+ avg | count | sum | count
+-----+-------+-----+-------
+(0 rows)
+
+select avg(a), count(b), sum(c), count(*) from test_int4 where a > 5120 and b > 0 group by b,c;
+ avg | count | sum | count
+-----+-------+-----+-------
+(0 rows)
+
+select avg(a), count(b), sum(c), count(*) from test_int8 where a > 5120 and b > 0 group by b,c;
+ avg | count | sum | count
+-----+-------+-----+-------
+(0 rows)
+
+select avg(a), count(b), sum(c), count(*) from test_float4 where a > 5120 and b > 0 group by b,c;
+ avg | count | sum | count
+-----+-------+-----+-------
+(0 rows)
+
+select avg(a), count(b), sum(c), count(*) from test_float8 where a > 5120 and b > 0 group by b,c;
+ avg | count | sum | count
+-----+-------+-----+-------
+(0 rows)
+
+select avg(a), count(b), sum(c), count(*) from test_int2 group by b,c;
+ avg | count | sum | count
+-----+-------+-----+-------
+ 8.5 | 16 | 32 | 16
+ | 0 | | 1
+(2 rows)
+
+select avg(a), count(b), sum(c), count(*) from test_int4 group by b,c;
+ avg | count | sum | count
+-----+-------+-----+-------
+ 8.5 | 16 | 32 | 16
+ | 0 | | 1
+(2 rows)
+
+select avg(a), count(b), sum(c), count(*) from test_int8 group by b,c;
+ avg | count | sum | count
+-----+-------+-----+-------
+ | 0 | | 1
+ 8.5 | 16 | 32 | 16
+(2 rows)
+
+select avg(a), count(b), sum(c), count(*) from test_float4 group by b,c;
+ avg | count | sum | count
+-----+-------+-----+-------
+ 8.5 | 16 | 32 | 16
+ | 0 | | 1
+(2 rows)
+
+select avg(a), count(b), sum(c), count(*) from test_float8 group by b,c;
+ avg | count | sum | count
+-----+-------+-----+-------
+ 8.5 | 16 | 32 | 16
+ | 0 | | 1
+(2 rows)
+
+select avg(a) from test_int2 group by b,c;
+ avg
+-----
+ 8.5
+
+(2 rows)
+
+select avg(a) from test_int4 group by b,c;
+ avg
+-----
+ 8.5
+
+(2 rows)
+
+select avg(a) from test_int8 group by b,c;
+ avg
+-----
+ 8.5
+
+(2 rows)
+
+select avg(a) from test_float4 group by b,c;
+ avg
+-----
+ 8.5
+
+(2 rows)
+
+select avg(a) from test_float8 group by b,c;
+ avg
+-----
+ 8.5
+
+(2 rows)
+
+select avg(a) from test_int2 where a > 5120 and b > 0 group by b,c;
+ avg
+-----
+(0 rows)
+
+select avg(a) from test_int4 where a > 5120 and b > 0 group by b,c;
+ avg
+-----
+(0 rows)
+
+select avg(a) from test_int8 where a > 5120 and b > 0 group by b,c;
+ avg
+-----
+(0 rows)
+
+select avg(a) from test_float4 where a > 5120 and b > 0 group by b,c;
+ avg
+-----
+(0 rows)
+
+select avg(a) from test_float8 where a > 5120 and b > 0 group by b,c;
+ avg
+-----
+(0 rows)
+
+select sum(a) from test_int2 group by b,c;
+ sum
+-----
+
+ 136
+(2 rows)
+
+select sum(a) from test_int4 group by b,c;
+ sum
+-----
+
+ 136
+(2 rows)
+
+select sum(a) from test_int8 group by b,c;
+ sum
+-----
+ 136
+
+(2 rows)
+
+select sum(a) from test_float4 group by b,c;
+ sum
+-----
+
+ 136
+(2 rows)
+
+select sum(a) from test_float8 group by b,c;
+ sum
+-----
+
+ 136
+(2 rows)
+
+select sum(a) from test_int2 where a > 5120 and b > 0 group by b,c;
+ sum
+-----
+(0 rows)
+
+select sum(a) from test_int4 where a > 5120 and b > 0 group by b,c;
+ sum
+-----
+(0 rows)
+
+select sum(a) from test_int8 where a > 5120 and b > 0 group by b,c;
+ sum
+-----
+(0 rows)
+
+select sum(a) from test_float4 where a > 5120 and b > 0 group by b,c;
+ sum
+-----
+(0 rows)
+
+select sum(a) from test_float8 where a > 5120 and b > 0 group by b,c;
+ sum
+-----
+(0 rows)
+
+select count(a) from test_int2 group by b,c;
+ count
+-------
+ 0
+ 16
+(2 rows)
+
+select count(a) from test_int4 group by b,c;
+ count
+-------
+ 0
+ 16
+(2 rows)
+
+select count(a) from test_int8 group by b,c;
+ count
+-------
+ 0
+ 16
+(2 rows)
+
+select count(a) from test_float4 group by b,c;
+ count
+-------
+ 0
+ 16
+(2 rows)
+
+select count(a) from test_float8 group by b,c;
+ count
+-------
+ 0
+ 16
+(2 rows)
+
+select count(a) from test_int2 where a > 5120 and b > 0 group by b,c;
+ count
+-------
+(0 rows)
+
+select count(a) from test_int4 where a > 5120 and b > 0 group by b,c;
+ count
+-------
+(0 rows)
+
+select count(a) from test_int8 where a > 5120 and b > 0 group by b,c;
+ count
+-------
+(0 rows)
+
+select count(a) from test_float4 where a > 5120 and b > 0 group by b,c;
+ count
+-------
+(0 rows)
+
+select count(a) from test_float8 where a > 5120 and b > 0 group by b,c;
+ count
+-------
+(0 rows)
+
+select count(*) from test_int2 group by b,c;
+ count
+-------
+ 1
+ 16
+(2 rows)
+
+select count(*) from test_int4 group by b,c;
+ count
+-------
+ 1
+ 16
+(2 rows)
+
+select count(*) from test_int8 group by b,c;
+ count
+-------
+ 1
+ 16
+(2 rows)
+
+select count(*) from test_float4 group by b,c;
+ count
+-------
+ 1
+ 16
+(2 rows)
+
+select count(*) from test_float8 group by b,c;
+ count
+-------
+ 1
+ 16
+(2 rows)
+
+select count(*) from test_int2 where a > 5120 and b > 0 group by b,c;
+ count
+-------
+(0 rows)
+
+select count(*) from test_int4 where a > 5120 and b > 0 group by b,c;
+ count
+-------
+(0 rows)
+
+select count(*) from test_int8 where a > 5120 and b > 0 group by b,c;
+ count
+-------
+(0 rows)
+
+select count(*) from test_float4 where a > 5120 and b > 0 group by b,c;
+ count
+-------
+(0 rows)
+
+select count(*) from test_float8 where a > 5120 and b > 0 group by b,c;
+ count
+-------
+(0 rows)
+
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/ce2814d4/src/test/feature/vexecutor/ans/vdate.ans
----------------------------------------------------------------------
diff --git a/src/test/feature/vexecutor/ans/vdate.ans b/src/test/feature/vexecutor/ans/vdate.ans
index 2564332..b484b8b 100644
--- a/src/test/feature/vexecutor/ans/vdate.ans
+++ b/src/test/feature/vexecutor/ans/vdate.ans
@@ -1,2082 +1,2103 @@
+-- start_ignore
+SET SEARCH_PATH=TestVexecutor_date;
+SET
+-- end_ignore
+SELECT '1998-08-01 1998-08-02 1998-08-03'::vdateadt;
vdateadt
----------------------------------
- 1998-08-01 1998-08-02 1998-08-03
+ 08-01-1998 08-02-1998 08-03-1998
(1 row)
+SELECT '1998-08-01 1998-08-02 1998-08-03'::vdateadt - '1 1 1'::vint4;
?column?
----------------------------------
- 1998-07-31 1998-08-01 1998-08-02
+ 07-31-1998 08-01-1998 08-02-1998
(1 row)
+SELECT '1998-08-01 1998-08-02 1998-08-03'::vdateadt + '1 1 1'::vint4;
?column?
----------------------------------
- 1998-08-02 1998-08-03 1998-08-04
+ 08-02-1998 08-03-1998 08-04-1998
(1 row)
+SELECT '1998-08-01 1998-08-02 1998-08-03'::vdateadt - '1998-07-30 1998-08-20 1998-08-03'::vdateadt;
?column?
----------
2 -18 0
(1 row)
+SELECT '1998-08-01 1998-08-02 1998-08-03'::vdateadt = '1998-07-30 1998-08-20 1998-08-03'::vdateadt;
?column?
----------
f f t
(1 row)
+SELECT '1998-08-01 1998-08-02 1998-08-03'::vdateadt > '1998-07-30 1998-08-20 1998-08-03'::vdateadt;
?column?
----------
t f f
(1 row)
+SELECT '1998-08-01 1998-08-02 1998-08-03'::vdateadt >= '1998-07-30 1998-08-20 1998-08-03'::vdateadt;
?column?
----------
t f t
(1 row)
+SELECT '1998-08-01 1998-08-02 1998-08-03'::vdateadt < '1998-07-30 1998-08-20 1998-08-03'::vdateadt;
?column?
----------
f t f
(1 row)
+SELECT '1998-08-01 1998-08-02 1998-08-03'::vdateadt <= '1998-07-30 1998-08-20 1998-08-03'::vdateadt;
?column?
----------
f t t
(1 row)
+SELECT '1998-08-01 1998-08-02 1998-08-03'::vdateadt <> '1998-07-30 1998-08-20 1998-08-03'::vdateadt;
?column?
----------
t t f
(1 row)
+select a + i from test1;
?column?
------------
- 1998-03-30
- 1998-03-31
- 1998-04-01
- 1998-04-02
- 1998-04-03
- 1998-04-04
- 1998-04-05
- 1998-04-06
- 1998-04-07
- 1998-04-08
- 1998-04-09
- 1998-04-10
- 1998-04-11
- 1998-04-12
- 1998-04-13
- 1998-04-14
- 1998-04-15
- 1998-04-16
- 1998-04-17
- 1998-04-18
- 1998-04-19
- 1998-04-20
- 1998-04-21
- 1998-04-22
- 1998-04-23
- 1998-04-24
- 1998-04-25
- 1998-04-26
- 1998-04-27
- 1998-04-28
- 1998-04-29
- 1998-04-30
- 1998-05-01
- 1998-05-02
- 1998-05-03
- 1998-05-04
- 1998-05-05
- 1998-05-06
- 1998-05-07
- 1998-05-08
- 1998-05-09
- 1998-05-10
- 1998-05-11
- 1998-05-12
- 1998-05-13
- 1998-05-14
- 1998-05-15
- 1998-05-16
- 1998-05-17
- 1998-05-18
- 1998-05-19
- 1998-05-20
- 1998-05-21
- 1998-05-22
- 1998-05-23
- 1998-05-24
- 1998-05-25
- 1998-05-26
- 1998-05-27
- 1998-05-28
- 1998-05-29
- 1998-05-30
- 1998-05-31
- 1998-06-01
- 1998-06-02
- 1998-06-03
- 1998-06-04
- 1998-06-05
- 1998-06-06
- 1998-06-07
- 1998-06-08
- 1998-06-09
- 1998-06-10
- 1998-06-11
- 1998-06-12
- 1998-06-13
- 1998-06-14
- 1998-06-15
- 1998-06-16
- 1998-06-17
- 1998-06-18
- 1998-06-19
- 1998-06-20
- 1998-06-21
- 1998-06-22
- 1998-06-23
- 1998-06-24
- 1998-06-25
- 1998-06-26
- 1998-06-27
- 1998-06-28
- 1998-06-29
- 1998-06-30
- 1998-07-01
- 1998-07-02
- 1998-07-03
- 1998-07-04
- 1998-07-05
- 1998-07-06
- 1998-07-07
- 1998-07-08
- 1998-07-09
- 1998-07-10
- 1998-07-11
- 1998-07-12
- 1998-07-13
- 1998-07-14
- 1998-07-15
- 1998-07-16
- 1998-07-17
- 1998-07-18
- 1998-07-19
- 1998-07-20
- 1998-07-21
- 1998-07-22
- 1998-07-23
- 1998-07-24
- 1998-07-25
- 1998-07-26
- 1998-07-27
- 1998-07-28
- 1998-07-29
- 1998-07-30
- 1998-07-31
- 1998-08-01
- 1998-08-02
- 1998-08-03
- 1998-08-04
- 1998-08-05
- 1998-08-06
- 1998-08-07
- 1998-08-08
- 1998-08-09
- 1998-08-10
- 1998-08-11
- 1998-08-12
- 1998-08-13
- 1998-08-14
- 1998-08-15
- 1998-08-16
- 1998-08-17
- 1998-08-18
- 1998-08-19
- 1998-08-20
- 1998-08-21
- 1998-08-22
- 1998-08-23
- 1998-08-24
- 1998-08-25
- 1998-08-26
- 1998-08-27
- 1998-08-28
- 1998-08-29
- 1998-08-30
- 1998-08-31
- 1998-09-01
- 1998-09-02
- 1998-09-03
- 1998-09-04
- 1998-09-05
- 1998-09-06
- 1998-09-07
- 1998-09-08
- 1998-09-09
- 1998-09-10
- 1998-09-11
- 1998-09-12
- 1998-09-13
- 1998-09-14
- 1998-09-15
- 1998-09-16
- 1998-09-17
- 1998-09-18
- 1998-09-19
- 1998-09-20
- 1998-09-21
- 1998-09-22
- 1998-09-23
- 1998-09-24
- 1998-09-25
- 1998-09-26
- 1998-09-27
- 1998-09-28
- 1998-09-29
- 1998-09-30
- 1998-10-01
- 1998-10-02
- 1998-10-03
- 1998-10-04
- 1998-10-05
- 1998-10-06
- 1998-10-07
- 1998-10-08
- 1998-10-09
- 1998-10-10
- 1998-10-11
- 1998-10-12
- 1998-10-13
- 1998-10-14
- 1998-10-15
- 1998-10-16
- 1998-10-17
- 1998-10-18
- 1998-10-19
- 1998-10-20
- 1998-10-21
- 1998-10-22
- 1998-10-23
- 1998-10-24
- 1998-10-25
- 1998-10-26
- 1998-10-27
- 1998-10-28
- 1998-10-29
- 1998-10-30
- 1998-10-31
- 1998-11-01
- 1998-11-02
- 1998-11-03
- 1998-11-04
- 1998-11-05
- 1998-11-06
- 1998-11-07
- 1998-11-08
- 1998-11-09
- 1998-11-10
- 1998-11-11
- 1998-11-12
- 1998-11-13
- 1998-11-14
- 1998-11-15
- 1998-11-16
- 1998-11-17
- 1998-11-18
- 1998-11-19
- 1998-11-20
- 1998-11-21
- 1998-11-22
- 1998-11-23
- 1998-11-24
- 1998-11-25
- 1998-11-26
- 1998-11-27
- 1998-11-28
- 1998-11-29
- 1998-11-30
- 1998-12-01
- 1998-12-02
- 1998-12-03
- 1998-12-04
- 1998-12-05
- 1998-12-06
- 1998-12-07
- 1998-12-08
- 1998-12-09
- 1998-12-10
- 1998-12-11
- 1998-12-12
- 1998-12-13
- 1998-12-14
- 1998-12-15
- 1998-12-16
- 1998-12-17
- 1998-12-18
- 1998-12-19
- 1998-12-20
- 1998-12-21
- 1998-12-22
- 1998-12-23
- 1998-12-24
- 1998-12-25
- 1998-12-26
- 1998-12-27
- 1998-12-28
- 1998-12-29
- 1998-12-30
- 1998-12-31
- 1999-01-01
- 1999-01-02
- 1999-01-03
- 1999-01-04
- 1999-01-05
- 1999-01-06
- 1999-01-07
- 1999-01-08
- 1999-01-09
- 1999-01-10
- 1999-01-11
- 1999-01-12
- 1999-01-13
- 1999-01-14
- 1999-01-15
- 1999-01-16
- 1999-01-17
- 1999-01-18
- 1999-01-19
- 1999-01-20
- 1999-01-21
- 1999-01-22
- 1999-01-23
- 1999-01-24
- 1999-01-25
- 1999-01-26
- 1999-01-27
- 1999-01-28
- 1999-01-29
- 1999-01-30
- 1999-01-31
- 1999-02-01
- 1999-02-02
- 1999-02-03
- 1999-02-04
- 1999-02-05
- 1999-02-06
- 1999-02-07
- 1999-02-08
- 1999-02-09
- 1999-02-10
- 1999-02-11
- 1999-02-12
- 1999-02-13
- 1999-02-14
- 1999-02-15
- 1999-02-16
- 1999-02-17
- 1999-02-18
- 1999-02-19
- 1999-02-20
- 1999-02-21
- 1999-02-22
- 1999-02-23
- 1999-02-24
- 1999-02-25
- 1999-02-26
- 1999-02-27
- 1999-02-28
- 1999-03-01
- 1999-03-02
- 1999-03-03
- 1999-03-04
- 1999-03-05
- 1999-03-06
- 1999-03-07
- 1999-03-08
- 1999-03-09
- 1999-03-10
- 1999-03-11
- 1999-03-12
- 1999-03-13
- 1999-03-14
- 1999-03-15
- 1999-03-16
- 1999-03-17
- 1999-03-18
- 1999-03-19
- 1999-03-20
- 1999-03-21
- 1999-03-22
- 1999-03-23
- 1999-03-24
- 1999-03-25
- 1999-03-26
- 1999-03-27
- 1999-03-28
- 1999-03-29
- 1999-03-30
- 1999-03-31
- 1999-04-01
- 1999-04-02
- 1999-04-03
- 1999-04-04
- 1999-04-05
- 1999-04-06
- 1999-04-07
- 1999-04-08
- 1999-04-09
- 1999-04-10
- 1999-04-11
- 1999-04-12
- 1999-04-13
- 1999-04-14
- 1999-04-15
- 1999-04-16
- 1999-04-17
- 1999-04-18
- 1999-04-19
- 1999-04-20
- 1999-04-21
- 1999-04-22
- 1999-04-23
- 1999-04-24
- 1999-04-25
- 1999-04-26
- 1999-04-27
- 1999-04-28
- 1999-04-29
- 1999-04-30
- 1999-05-01
- 1999-05-02
- 1999-05-03
- 1999-05-04
- 1999-05-05
- 1999-05-06
- 1999-05-07
- 1999-05-08
- 1999-05-09
- 1999-05-10
- 1999-05-11
- 1999-05-12
- 1999-05-13
- 1999-05-14
- 1999-05-15
- 1999-05-16
- 1999-05-17
- 1999-05-18
- 1999-05-19
- 1999-05-20
- 1999-05-21
- 1999-05-22
- 1999-05-23
- 1999-05-24
- 1999-05-25
- 1999-05-26
- 1999-05-27
- 1999-05-28
- 1999-05-29
- 1999-05-30
- 1999-05-31
- 1999-06-01
- 1999-06-02
- 1999-06-03
- 1999-06-04
- 1999-06-05
- 1999-06-06
- 1999-06-07
- 1999-06-08
- 1999-06-09
- 1999-06-10
- 1999-06-11
- 1999-06-12
- 1999-06-13
- 1999-06-14
- 1999-06-15
- 1999-06-16
- 1999-06-17
- 1999-06-18
- 1999-06-19
- 1999-06-20
- 1999-06-21
- 1999-06-22
- 1999-06-23
- 1999-06-24
- 1999-06-25
- 1999-06-26
- 1999-06-27
- 1999-06-28
- 1999-06-29
- 1999-06-30
- 1999-07-01
- 1999-07-02
- 1999-07-03
- 1999-07-04
- 1999-07-05
- 1999-07-06
- 1999-07-07
- 1999-07-08
- 1999-07-09
- 1999-07-10
- 1999-07-11
- 1999-07-12
- 1999-07-13
- 1999-07-14
- 1999-07-15
- 1999-07-16
- 1999-07-17
- 1999-07-18
- 1999-07-19
- 1999-07-20
- 1999-07-21
- 1999-07-22
- 1999-07-23
- 1999-07-24
- 1999-07-25
- 1999-07-26
- 1999-07-27
- 1999-07-28
- 1999-07-29
- 1999-07-30
- 1999-07-31
- 1999-08-01
- 1999-08-02
- 1999-08-03
- 1999-08-04
- 1999-08-05
- 1999-08-06
- 1999-08-07
- 1999-08-08
- 1999-08-09
- 1999-08-10
- 1999-08-11
- 1999-08-12
- 1999-08-13
- 1999-08-14
- 1999-08-15
- 1999-08-16
- 1999-08-17
- 1999-08-18
- 1999-08-19
- 1999-08-20
- 1999-08-21
- 1999-08-22
- 1999-08-23
- 1999-08-24
- 1999-08-25
- 1999-08-26
- 1999-08-27
- 1999-08-28
- 1999-08-29
- 1999-08-30
- 1999-08-31
- 1999-09-01
- 1999-09-02
- 1999-09-03
- 1999-09-04
- 1999-09-05
- 1999-09-06
- 1999-09-07
- 1999-09-08
- 1999-09-09
- 1999-09-10
- 1999-09-11
- 1999-09-12
- 1999-09-13
- 1999-09-14
- 1999-09-15
- 1999-09-16
- 1999-09-17
- 1999-09-18
- 1999-09-19
- 1999-09-20
- 1999-09-21
- 1999-09-22
- 1999-09-23
- 1999-09-24
- 1999-09-25
- 1999-09-26
- 1999-09-27
- 1999-09-28
- 1999-09-29
- 1999-09-30
- 1999-10-01
- 1999-10-02
- 1999-10-03
- 1999-10-04
- 1999-10-05
- 1999-10-06
- 1999-10-07
- 1999-10-08
- 1999-10-09
- 1999-10-10
- 1999-10-11
- 1999-10-12
- 1999-10-13
- 1999-10-14
- 1999-10-15
- 1999-10-16
- 1999-10-17
- 1999-10-18
- 1999-10-19
- 1999-10-20
- 1999-10-21
- 1999-10-22
- 1999-10-23
- 1999-10-24
- 1999-10-25
- 1999-10-26
- 1999-10-27
- 1999-10-28
- 1999-10-29
- 1999-10-30
- 1999-10-31
- 1999-11-01
- 1999-11-02
- 1999-11-03
- 1999-11-04
- 1999-11-05
- 1999-11-06
- 1999-11-07
- 1999-11-08
- 1999-11-09
- 1999-11-10
- 1999-11-11
- 1999-11-12
- 1999-11-13
- 1999-11-14
- 1999-11-15
- 1999-11-16
- 1999-11-17
- 1999-11-18
- 1999-11-19
- 1999-11-20
- 1999-11-21
- 1999-11-22
- 1999-11-23
- 1999-11-24
- 1999-11-25
- 1999-11-26
- 1999-11-27
- 1999-11-28
- 1999-11-29
- 1999-11-30
- 1999-12-01
- 1999-12-02
- 1999-12-03
- 1999-12-04
- 1999-12-05
- 1999-12-06
- 1999-12-07
- 1999-12-08
- 1999-12-09
- 1999-12-10
- 1999-12-11
- 1999-12-12
- 1999-12-13
- 1999-12-14
- 1999-12-15
- 1999-12-16
- 1999-12-17
- 1999-12-18
- 1999-12-19
- 1999-12-20
- 1999-12-21
- 1999-12-22
- 1999-12-23
- 1999-12-24
- 1999-12-25
- 1999-12-26
- 1999-12-27
- 1999-12-28
- 1999-12-29
- 1999-12-30
- 1999-12-31
- 2000-01-01
- 2000-01-02
- 2000-01-03
- 2000-01-04
- 2000-01-05
- 2000-01-06
- 2000-01-07
- 2000-01-08
- 2000-01-09
- 2000-01-10
- 2000-01-11
- 2000-01-12
- 2000-01-13
- 2000-01-14
- 2000-01-15
- 2000-01-16
- 2000-01-17
- 2000-01-18
- 2000-01-19
- 2000-01-20
- 2000-01-21
- 2000-01-22
- 2000-01-23
- 2000-01-24
- 2000-01-25
- 2000-01-26
- 2000-01-27
- 2000-01-28
- 2000-01-29
- 2000-01-30
- 2000-01-31
- 2000-02-01
- 2000-02-02
- 2000-02-03
- 2000-02-04
- 2000-02-05
- 2000-02-06
- 2000-02-07
- 2000-02-08
- 2000-02-09
- 2000-02-10
- 2000-02-11
- 2000-02-12
- 2000-02-13
- 2000-02-14
- 2000-02-15
- 2000-02-16
- 2000-02-17
- 2000-02-18
- 2000-02-19
- 2000-02-20
- 2000-02-21
- 2000-02-22
- 2000-02-23
- 2000-02-24
- 2000-02-25
- 2000-02-26
- 2000-02-27
- 2000-02-28
- 2000-02-29
- 2000-03-01
- 2000-03-02
- 2000-03-03
- 2000-03-04
- 2000-03-05
- 2000-03-06
- 2000-03-07
- 2000-03-08
- 2000-03-09
- 2000-03-10
- 2000-03-11
- 2000-03-12
- 2000-03-13
- 2000-03-14
- 2000-03-15
- 2000-03-16
- 2000-03-17
- 2000-03-18
- 2000-03-19
- 2000-03-20
- 2000-03-21
- 2000-03-22
- 2000-03-23
- 2000-03-24
- 2000-03-25
- 2000-03-26
- 2000-03-27
- 2000-03-28
- 2000-03-29
- 2000-03-30
- 2000-03-31
- 2000-04-01
- 2000-04-02
- 2000-04-03
- 2000-04-04
- 2000-04-05
- 2000-04-06
- 2000-04-07
- 2000-04-08
- 2000-04-09
- 2000-04-10
- 2000-04-11
- 2000-04-12
- 2000-04-13
- 2000-04-14
- 2000-04-15
- 2000-04-16
- 2000-04-17
- 2000-04-18
- 2000-04-19
- 2000-04-20
- 2000-04-21
- 2000-04-22
- 2000-04-23
- 2000-04-24
- 2000-04-25
- 2000-04-26
- 2000-04-27
- 2000-04-28
- 2000-04-29
- 2000-04-30
- 2000-05-01
- 2000-05-02
- 2000-05-03
- 2000-05-04
- 2000-05-05
- 2000-05-06
- 2000-05-07
- 2000-05-08
- 2000-05-09
- 2000-05-10
- 2000-05-11
- 2000-05-12
- 2000-05-13
- 2000-05-14
- 2000-05-15
- 2000-05-16
- 2000-05-17
- 2000-05-18
- 2000-05-19
- 2000-05-20
- 2000-05-21
- 2000-05-22
- 2000-05-23
- 2000-05-24
- 2000-05-25
- 2000-05-26
- 2000-05-27
- 2000-05-28
- 2000-05-29
- 2000-05-30
- 2000-05-31
- 2000-06-01
- 2000-06-02
- 2000-06-03
- 2000-06-04
- 2000-06-05
- 2000-06-06
- 2000-06-07
- 2000-06-08
- 2000-06-09
- 2000-06-10
- 2000-06-11
- 2000-06-12
- 2000-06-13
- 2000-06-14
- 2000-06-15
- 2000-06-16
- 2000-06-17
- 2000-06-18
- 2000-06-19
- 2000-06-20
- 2000-06-21
- 2000-06-22
- 2000-06-23
- 2000-06-24
- 2000-06-25
- 2000-06-26
- 2000-06-27
- 2000-06-28
- 2000-06-29
- 2000-06-30
- 2000-07-01
- 2000-07-02
- 2000-07-03
- 2000-07-04
- 2000-07-05
- 2000-07-06
- 2000-07-07
- 2000-07-08
- 2000-07-09
- 2000-07-10
- 2000-07-11
- 2000-07-12
- 2000-07-13
- 2000-07-14
- 2000-07-15
- 2000-07-16
- 2000-07-17
- 2000-07-18
- 2000-07-19
- 2000-07-20
- 2000-07-21
- 2000-07-22
- 2000-07-23
- 2000-07-24
- 2000-07-25
- 2000-07-26
- 2000-07-27
- 2000-07-28
- 2000-07-29
- 2000-07-30
- 2000-07-31
- 2000-08-01
- 2000-08-02
- 2000-08-03
- 2000-08-04
- 2000-08-05
- 2000-08-06
- 2000-08-07
- 2000-08-08
- 2000-08-09
- 2000-08-10
- 2000-08-11
- 2000-08-12
- 2000-08-13
- 2000-08-14
- 2000-08-15
- 2000-08-16
- 2000-08-17
- 2000-08-18
- 2000-08-19
- 2000-08-20
- 2000-08-21
- 2000-08-22
- 2000-08-23
- 2000-08-24
- 2000-08-25
- 2000-08-26
- 2000-08-27
- 2000-08-28
- 2000-08-29
- 2000-08-30
- 2000-08-31
- 2000-09-01
- 2000-09-02
- 2000-09-03
- 2000-09-04
- 2000-09-05
- 2000-09-06
- 2000-09-07
- 2000-09-08
- 2000-09-09
- 2000-09-10
- 2000-09-11
- 2000-09-12
- 2000-09-13
- 2000-09-14
- 2000-09-15
- 2000-09-16
- 2000-09-17
- 2000-09-18
- 2000-09-19
- 2000-09-20
- 2000-09-21
- 2000-09-22
- 2000-09-23
- 2000-09-24
- 2000-09-25
- 2000-09-26
- 2000-09-27
- 2000-09-28
- 2000-09-29
- 2000-09-30
- 2000-10-01
- 2000-10-02
- 2000-10-03
- 2000-10-04
- 2000-10-05
- 2000-10-06
- 2000-10-07
- 2000-10-08
- 2000-10-09
- 2000-10-10
- 2000-10-11
- 2000-10-12
- 2000-10-13
- 2000-10-14
- 2000-10-15
- 2000-10-16
- 2000-10-17
- 2000-10-18
- 2000-10-19
- 2000-10-20
- 2000-10-21
- 2000-10-22
- 2000-10-23
- 2000-10-24
- 2000-10-25
- 2000-10-26
- 2000-10-27
- 2000-10-28
- 2000-10-29
- 2000-10-30
- 2000-10-31
- 2000-11-01
- 2000-11-02
- 2000-11-03
- 2000-11-04
- 2000-11-05
- 2000-11-06
- 2000-11-07
- 2000-11-08
- 2000-11-09
- 2000-11-10
- 2000-11-11
- 2000-11-12
- 2000-11-13
- 2000-11-14
- 2000-11-15
- 2000-11-16
- 2000-11-17
- 2000-11-18
- 2000-11-19
- 2000-11-20
- 2000-11-21
- 2000-11-22
- 2000-11-23
- 2000-11-24
- 2000-11-25
- 2000-11-26
- 2000-11-27
- 2000-11-28
- 2000-11-29
- 2000-11-30
- 2000-12-01
- 2000-12-02
- 2000-12-03
- 2000-12-04
- 2000-12-05
- 2000-12-06
- 2000-12-07
- 2000-12-08
- 2000-12-09
- 2000-12-10
- 2000-12-11
- 2000-12-12
- 2000-12-13
- 2000-12-14
- 2000-12-15
- 2000-12-16
- 2000-12-17
- 2000-12-18
- 2000-12-19
- 2000-12-20
- 2000-12-21
- 2000-12-22
- 2000-12-23
- 2000-12-24
- 2000-12-25
- 2000-12-26
- 2000-12-27
- 2000-12-28
- 2000-12-29
- 2000-12-30
- 2000-12-31
- 2001-01-01
- 2001-01-02
- 2001-01-03
- 2001-01-04
- 2001-01-05
- 2001-01-06
- 2001-01-07
- 2001-01-08
- 2001-01-09
- 2001-01-10
- 2001-01-11
- 2001-01-12
- 2001-01-13
- 2001-01-14
- 2001-01-15
- 2001-01-16
- 2001-01-17
- 2001-01-18
- 2001-01-19
- 2001-01-20
- 2001-01-21
- 2001-01-22
- 2001-01-23
- 2001-01-24
- 2001-01-25
- 2001-01-26
- 2001-01-27
- 2001-01-28
- 2001-01-29
- 2001-01-30
- 2001-01-31
- 2001-02-01
- 2001-02-02
- 2001-02-03
- 2001-02-04
- 2001-02-05
- 2001-02-06
- 2001-02-07
- 2001-02-08
- 2001-02-09
- 2001-02-10
- 2001-02-11
- 2001-02-12
- 2001-02-13
- 2001-02-14
- 2001-02-15
- 2001-02-16
- 2001-02-17
- 2001-02-18
- 2001-02-19
- 2001-02-20
- 2001-02-21
- 2001-02-22
- 2001-02-23
- 2001-02-24
- 2001-02-25
- 2001-02-26
- 2001-02-27
- 2001-02-28
- 2001-03-01
- 2001-03-02
- 2001-03-03
- 2001-03-04
- 2001-03-05
- 2001-03-06
- 2001-03-07
- 2001-03-08
- 2001-03-09
- 2001-03-10
- 2001-03-11
- 2001-03-12
- 2001-03-13
- 2001-03-14
- 2001-03-15
- 2001-03-16
- 2001-03-17
- 2001-03-18
- 2001-03-19
- 2001-03-20
- 2001-03-21
- 2001-03-22
- 2001-03-23
- 2001-03-24
- 2001-03-25
- 2001-03-26
- 2001-03-27
- 2001-03-28
- 2001-03-29
- 2001-03-30
- 2001-03-31
- 2001-04-01
- 2001-04-02
- 2001-04-03
- 2001-04-04
- 2001-04-05
- 2001-04-06
- 2001-04-07
- 2001-04-08
- 2001-04-09
- 2001-04-10
- 2001-04-11
- 2001-04-12
- 2001-04-13
- 2001-04-14
- 2001-04-15
- 2001-04-16
- 2001-04-17
- 2001-04-18
- 2001-04-19
- 2001-04-20
- 2001-04-21
- 2001-04-22
- 2001-04-23
- 2001-04-24
- 2001-04-25
- 2001-04-26
- 2001-04-27
- 2001-04-28
- 2001-04-29
- 2001-04-30
- 2001-05-01
- 2001-05-02
- 2001-05-03
- 2001-05-04
- 2001-05-05
- 2001-05-06
- 2001-05-07
- 2001-05-08
- 2001-05-09
- 2001-05-10
- 2001-05-11
- 2001-05-12
- 2001-05-13
- 2001-05-14
- 2001-05-15
- 2001-05-16
- 2001-05-17
- 2001-05-18
- 2001-05-19
- 2001-05-20
- 2001-05-21
- 2001-05-22
- 2001-05-23
- 2001-05-24
- 2001-05-25
- 2001-05-26
- 2001-05-27
- 2001-05-28
- 2001-05-29
- 2001-05-30
- 2001-05-31
- 2001-06-01
- 2001-06-02
- 2001-06-03
- 2001-06-04
- 2001-06-05
- 2001-06-06
- 2001-06-07
- 2001-06-08
- 2001-06-09
- 2001-06-10
- 2001-06-11
- 2001-06-12
- 2001-06-13
- 2001-06-14
- 2001-06-15
- 2001-06-16
- 2001-06-17
- 2001-06-18
- 2001-06-19
- 2001-06-20
- 2001-06-21
- 2001-06-22
- 2001-06-23
- 2001-06-24
- 2001-06-25
- 2001-06-26
- 2001-06-27
- 2001-06-28
- 2001-06-29
- 2001-06-30
- 2001-07-01
- 2001-07-02
- 2001-07-03
- 2001-07-04
- 2001-07-05
- 2001-07-06
- 2001-07-07
- 2001-07-08
- 2001-07-09
- 2001-07-10
- 2001-07-11
- 2001-07-12
- 2001-07-13
- 2001-07-14
- 2001-07-15
- 2001-07-16
- 2001-07-17
- 2001-07-18
- 2001-07-19
- 2001-07-20
- 2001-07-21
- 2001-07-22
- 2001-07-23
- 2001-07-24
- 2001-07-25
- 2001-07-26
- 2001-07-27
- 2001-07-28
- 2001-07-29
- 2001-07-30
- 2001-07-31
- 2001-08-01
- 2001-08-02
- 2001-08-03
- 2001-08-04
- 2001-08-05
- 2001-08-06
- 2001-08-07
- 2001-08-08
- 2001-08-09
- 2001-08-10
- 2001-08-11
- 2001-08-12
- 2001-08-13
- 2001-08-14
- 2001-08-15
- 2001-08-16
- 2001-08-17
- 2001-08-18
- 2001-08-19
- 2001-08-20
- 2001-08-21
- 2001-08-22
- 2001-08-23
- 2001-08-24
- 2001-08-25
- 2001-08-26
- 2001-08-27
- 2001-08-28
- 2001-08-29
- 2001-08-30
- 2001-08-31
- 2001-09-01
- 2001-09-02
- 2001-09-03
- 2001-09-04
- 2001-09-05
- 2001-09-06
- 2001-09-07
- 2001-09-08
- 2001-09-09
- 2001-09-10
- 2001-09-11
- 2001-09-12
- 2001-09-13
- 2001-09-14
- 2001-09-15
- 2001-09-16
- 2001-09-17
- 2001-09-18
- 2001-09-19
- 2001-09-20
- 2001-09-21
- 2001-09-22
- 2001-09-23
- 2001-09-24
- 2001-09-25
- 2001-09-26
- 2001-09-27
- 2001-09-28
- 2001-09-29
- 2001-09-30
- 2001-10-01
- 2001-10-02
- 2001-10-03
- 2001-10-04
- 2001-10-05
- 2001-10-06
- 2001-10-07
- 2001-10-08
- 2001-10-09
- 2001-10-10
- 2001-10-11
- 2001-10-12
- 2001-10-13
- 2001-10-14
- 2001-10-15
- 2001-10-16
- 2001-10-17
- 2001-10-18
- 2001-10-19
- 2001-10-20
- 2001-10-21
- 2001-10-22
- 2001-10-23
- 2001-10-24
- 2001-10-25
- 2001-10-26
- 2001-10-27
- 2001-10-28
- 2001-10-29
- 2001-10-30
- 2001-10-31
- 2001-11-01
- 2001-11-02
- 2001-11-03
- 2001-11-04
- 2001-11-05
- 2001-11-06
- 2001-11-07
- 2001-11-08
- 2001-11-09
- 2001-11-10
- 2001-11-11
- 2001-11-12
- 2001-11-13
- 2001-11-14
- 2001-11-15
- 2001-11-16
- 2001-11-17
- 2001-11-18
- 2001-11-19
- 2001-11-20
- 2001-11-21
- 2001-11-22
- 2001-11-23
- 2001-11-24
- 2001-11-25
- 2001-11-26
- 2001-11-27
- 2001-11-28
- 2001-11-29
- 2001-11-30
- 2001-12-01
- 2001-12-02
- 2001-12-03
- 2001-12-04
- 2001-12-05
- 2001-12-06
- 2001-12-07
- 2001-12-08
- 2001-12-09
- 2001-12-10
- 2001-12-11
- 2001-12-12
- 2001-12-13
- 2001-12-14
- 2001-12-15
- 2001-12-16
- 2001-12-17
- 2001-12-18
- 2001-12-19
- 2001-12-20
- 2001-12-21
- 2001-12-22
- 2001-12-23
- 2001-12-24
- 2001-12-25
- 2001-12-26
- 2001-12-27
- 2001-12-28
- 2001-12-29
- 2001-12-30
- 2001-12-31
- 2002-01-01
- 2002-01-02
- 2002-01-03
- 2002-01-04
- 2002-01-05
- 2002-01-06
- 2002-01-07
- 2002-01-08
- 2002-01-09
- 2002-01-10
- 2002-01-11
- 2002-01-12
- 2002-01-13
- 2002-01-14
- 2002-01-15
- 2002-01-16
- 2002-01-17
- 2002-01-18
- 2002-01-19
- 2002-01-20
- 2002-01-21
- 2002-01-22
- 2002-01-23
- 2002-01-24
- 2002-01-25
- 2002-01-26
- 2002-01-27
- 2002-01-28
- 2002-01-29
- 2002-01-30
- 2002-01-31
- 2002-02-01
- 2002-02-02
- 2002-02-03
- 2002-02-04
- 2002-02-05
- 2002-02-06
- 2002-02-07
- 2002-02-08
- 2002-02-09
- 2002-02-10
- 2002-02-11
- 2002-02-12
- 2002-02-13
- 2002-02-14
- 2002-02-15
- 2002-02-16
- 2002-02-17
- 2002-02-18
- 2002-02-19
- 2002-02-20
- 2002-02-21
- 2002-02-22
- 2002-02-23
- 2002-02-24
- 2002-02-25
- 2002-02-26
- 2002-02-27
- 2002-02-28
- 2002-03-01
- 2002-03-02
- 2002-03-03
- 2002-03-04
- 2002-03-05
- 2002-03-06
- 2002-03-07
- 2002-03-08
- 2002-03-09
- 2002-03-10
- 2002-03-11
- 2002-03-12
- 2002-03-13
- 2002-03-14
- 2002-03-15
- 2002-03-16
- 2002-03-17
- 2002-03-18
- 2002-03-19
- 2002-03-20
- 2002-03-21
- 2002-03-22
- 2002-03-23
- 2002-03-24
- 2002-03-25
- 2002-03-26
- 2002-03-27
- 2002-03-28
- 2002-03-29
- 2002-03-30
- 2002-03-31
- 2002-04-01
- 2002-04-02
- 2002-04-03
- 2002-04-04
- 2002-04-05
- 2002-04-06
- 2002-04-07
- 2002-04-08
- 2002-04-09
- 2002-04-10
- 2002-04-11
- 2002-04-12
- 2002-04-13
- 2002-04-14
- 2002-04-15
- 2002-04-16
- 2002-04-17
- 2002-04-18
- 2002-04-19
- 2002-04-20
- 2002-04-21
- 2002-04-22
- 2002-04-23
- 2002-04-24
- 2002-04-25
- 2002-04-26
- 2002-04-27
- 2002-04-28
- 2002-04-29
- 2002-04-30
- 2002-05-01
- 2002-05-02
- 2002-05-03
- 2002-05-04
- 2002-05-05
- 2002-05-06
- 2002-05-07
- 2002-05-08
- 2002-05-09
- 2002-05-10
- 2002-05-11
- 2002-05-12
- 2002-05-13
- 2002-05-14
- 2002-05-15
- 2002-05-16
- 2002-05-17
- 2002-05-18
- 2002-05-19
- 2002-05-20
- 2002-05-21
- 2002-05-22
- 2002-05-23
- 2002-05-24
- 2002-05-25
- 2002-05-26
- 2002-05-27
- 2002-05-28
- 2002-05-29
- 2002-05-30
- 2002-05-31
- 2002-06-01
- 2002-06-02
- 2002-06-03
- 2002-06-04
- 2002-06-05
- 2002-06-06
- 2002-06-07
- 2002-06-08
- 2002-06-09
- 2002-06-10
- 2002-06-11
- 2002-06-12
- 2002-06-13
- 2002-06-14
- 2002-06-15
- 2002-06-16
- 2002-06-17
- 2002-06-18
- 2002-06-19
- 2002-06-20
- 2002-06-21
- 2002-06-22
- 2002-06-23
- 2002-06-24
- 2002-06-25
- 2002-06-26
- 2002-06-27
- 2002-06-28
- 2002-06-29
- 2002-06-30
- 2002-07-01
- 2002-07-02
- 2002-07-03
- 2002-07-04
- 2002-07-05
- 2002-07-06
- 2002-07-07
- 2002-07-08
- 2002-07-09
- 2002-07-10
- 2002-07-11
- 2002-07-12
- 2002-07-13
- 2002-07-14
- 2002-07-15
- 2002-07-16
- 2002-07-17
- 2002-07-18
- 2002-07-19
- 2002-07-20
- 2002-07-21
- 2002-07-22
- 2002-07-23
- 2002-07-24
- 2002-07-25
- 2002-07-26
- 2002-07-27
- 2002-07-28
- 2002-07-29
- 2002-07-30
- 2002-07-31
- 2002-08-01
- 2002-08-02
- 2002-08-03
- 2002-08-04
- 2002-08-05
- 2002-08-06
- 2002-08-07
- 2002-08-08
- 2002-08-09
- 2002-08-10
- 2002-08-11
- 2002-08-12
- 2002-08-13
- 2002-08-14
- 2002-08-15
- 2002-08-16
- 2002-08-17
- 2002-08-18
- 2002-08-19
- 2002-08-20
- 2002-08-21
- 2002-08-22
- 2002-08-23
- 2002-08-24
- 2002-08-25
- 2002-08-26
- 2002-08-27
- 2002-08-28
- 2002-08-29
- 2002-08-30
- 2002-08-31
- 2002-09-01
- 2002-09-02
- 2002-09-03
- 2002-09-04
- 2002-09-05
- 2002-09-06
- 2002-09-07
- 2002-09-08
- 2002-09-09
- 2002-09-10
- 2002-09-11
- 2002-09-12
- 2002-09-13
- 2002-09-14
- 2002-09-15
- 2002-09-16
- 2002-09-17
- 2002-09-18
- 2002-09-19
- 2002-09-20
- 2002-09-21
- 2002-09-22
- 2002-09-23
- 2002-09-24
- 2002-09-25
- 2002-09-26
- 2002-09-27
- 2002-09-28
- 2002-09-29
- 2002-09-30
- 2002-10-01
- 2002-10-02
- 2002-10-03
- 2002-10-04
- 2002-10-05
- 2002-10-06
- 2002-10-07
- 2002-10-08
- 2002-10-09
- 2002-10-10
- 2002-10-11
- 2002-10-12
- 2002-10-13
- 2002-10-14
- 2002-10-15
- 2002-10-16
- 2002-10-17
- 2002-10-18
- 2002-10-19
- 2002-10-20
- 2002-10-21
- 2002-10-22
- 2002-10-23
- 2002-10-24
- 2002-10-25
- 2002-10-26
- 2002-10-27
- 2002-10-28
- 2002-10-29
- 2002-10-30
- 2002-10-31
- 2002-11-01
- 2002-11-02
- 2002-11-03
- 2002-11-04
- 2002-11-05
- 2002-11-06
- 2002-11-07
- 2002-11-08
- 2002-11-09
- 2002-11-10
- 2002-11-11
- 2002-11-12
- 2002-11-13
- 2002-11-14
- 2002-11-15
- 2002-11-16
- 2002-11-17
- 2002-11-18
- 2002-11-19
- 2002-11-20
- 2002-11-21
- 2002-11-22
- 2002-11-23
- 2002-11-24
- 2002-11-25
- 2002-11-26
- 2002-11-27
- 2002-11-28
- 2002-11-29
- 2002-11-30
- 2002-12-01
- 2002-12-02
- 2002-12-03
- 2002-12-04
- 2002-12-05
- 2002-12-06
- 2002-12-07
- 2002-12-08
- 2002-12-09
- 2002-12-10
- 2002-12-11
- 2002-12-12
- 2002-12-13
- 2002-12-14
- 2002-12-15
- 2002-12-16
- 2002-12-17
- 2002-12-18
- 2002-12-19
- 2002-12-20
- 2002-12-21
- 2002-12-22
- 2002-12-23
- 2002-12-24
- 2002-12-25
- 2002-12-26
- 2002-12-27
- 2002-12-28
- 2002-12-29
- 2002-12-30
- 2002-12-31
- 2003-01-01
- 2003-01-02
- 2003-01-03
- 2003-01-04
- 2003-01-05
- 2003-01-06
- 2003-01-07
- 2003-01-08
- 2003-01-09
- 2003-01-10
- 2003-01-11
- 2003-01-12
- 2003-01-13
- 2003-01-14
- 2003-01-15
- 2003-01-16
- 2003-01-17
- 2003-01-18
- 2003-01-19
- 2003-01-20
- 2003-01-21
- 2003-01-22
- 2003-01-23
- 2003-01-24
- 2003-01-25
- 2003-01-26
- 2003-01-27
- 2003-01-28
- 2003-01-29
- 2003-01-30
- 2003-01-31
- 2003-02-01
- 2003-02-02
- 2003-02-03
- 2003-02-04
- 2003-02-05
- 2003-02-06
- 2003-02-07
- 2003-02-08
- 2003-02-09
- 2003-02-10
- 2003-02-11
- 2003-02-12
- 2003-02-13
- 2003-02-14
- 2003-02-15
- 2003-02-16
- 2003-02-17
- 2003-02-18
- 2003-02-19
- 2003-02-20
- 2003-02-21
- 2003-02-22
- 2003-02-23
- 2003-02-24
- 2003-02-25
- 2003-02-26
- 2003-02-27
- 2003-02-28
- 2003-03-01
- 2003-03-02
- 2003-03-03
- 2003-03-04
- 2003-03-05
- 2003-03-06
- 2003-03-07
- 2003-03-08
- 2003-03-09
- 2003-03-10
- 2003-03-11
- 2003-03-12
- 2003-03-13
- 2003-03-14
- 2003-03-15
- 2003-03-16
- 2003-03-17
- 2003-03-18
- 2003-03-19
- 2003-03-20
- 2003-03-21
- 2003-03-22
- 2003-03-23
- 2003-03-24
- 2003-03-25
- 2003-03-26
- 2003-03-27
- 2003-03-28
- 2003-03-29
- 2003-03-30
- 2003-03-31
- 2003-04-01
- 2003-04-02
- 2003-04-03
- 2003-04-04
- 2003-04-05
- 2003-04-06
- 2003-04-07
- 2003-04-08
- 2003-04-09
- 2003-04-10
- 2003-04-11
- 2003-04-12
- 2003-04-13
- 2003-04-14
- 2003-04-15
- 2003-04-16
- 2003-04-17
- 2003-04-18
- 2003-04-19
- 2003-04-20
- 2003-04-21
- 2003-04-22
- 2003-04-23
- 2003-04-24
- 2003-04-25
- 2003-04-26
- 2003-04-27
- 2003-04-28
- 2003-04-29
- 2003-04-30
- 2003-05-01
- 2003-05-02
- 2003-05-03
- 2003-05-04
- 2003-05-05
- 2003-05-06
- 2003-05-07
- 2003-05-08
- 2003-05-09
- 2003-05-10
- 2003-05-11
- 2003-05-12
- 2003-05-13
- 2003-05-14
- 2003-05-15
- 2003-05-16
- 2003-05-17
- 2003-05-18
- 2003-05-19
- 2003-05-20
- 2003-05-21
- 2003-05-22
- 2003-05-23
- 2003-05-24
- 2003-05-25
- 2003-05-26
- 2003-05-27
- 2003-05-28
- 2003-05-29
- 2003-05-30
- 2003-05-31
- 2003-06-01
- 2003-06-02
- 2003-06-03
- 2003-06-04
- 2003-06-05
- 2003-06-06
- 2003-06-07
- 2003-06-08
- 2003-06-09
- 2003-06-10
- 2003-06-11
- 2003-06-12
- 2003-06-13
- 2003-06-14
- 2003-06-15
- 2003-06-16
- 2003-06-17
- 2003-06-18
- 2003-06-19
- 2003-06-20
- 2003-06-21
- 2003-06-22
- 2003-06-23
- 2003-06-24
- 2003-06-25
- 2003-06-26
- 2003-06-27
- 2003-06-28
- 2003-06-29
- 2003-06-30
- 2003-07-01
- 2003-07-02
- 2003-07-03
- 2003-07-04
- 2003-07-05
- 2003-07-06
- 2003-07-07
- 2003-07-08
- 2003-07-09
- 2003-07-10
- 2003-07-11
- 2003-07-12
- 2003-07-13
- 2003-07-14
- 2003-07-15
- 2003-07-16
- 2003-07-17
- 2003-07-18
- 2003-07-19
- 2003-07-20
- 2003-07-21
- 2003-07-22
- 2003-07-23
- 2003-07-24
- 2003-07-25
- 2003-07-26
- 2003-07-27
- 2003-07-28
- 2003-07-29
- 2003-07-30
- 2003-07-31
- 2003-08-01
- 2003-08-02
- 2003-08-03
- 2003-08-04
- 2003-08-05
- 2003-08-06
- 2003-08-07
- 2003-08-08
- 2003-08-09
- 2003-08-10
- 2003-08-11
- 2003-08-12
- 2003-08-13
- 2003-08-14
- 2003-08-15
- 2003-08-16
- 2003-08-17
- 2003-08-18
- 2003-08-19
- 2003-08-20
- 2003-08-21
- 2003-08-22
- 2003-08-23
- 2003-08-24
- 2003-08-25
- 2003-08-26
- 2003-08-27
- 2003-08-28
- 2003-08-29
- 2003-08-30
- 2003-08-31
- 2003-09-01
- 2003-09-02
- 2003-09-03
- 2003-09-04
- 2003-09-05
- 2003-09-06
- 2003-09-07
- 2003-09-08
- 2003-09-09
- 2003-09-10
- 2003-09-11
- 2003-09-12
- 2003-09-13
- 2003-09-14
- 2003-09-15
- 2003-09-16
- 2003-09-17
- 2003-09-18
- 2003-09-19
+ 03-30-1998
+ 03-31-1998
+ 04-01-1998
+ 04-02-1998
+ 04-03-1998
+ 04-04-1998
+ 04-05-1998
+ 04-06-1998
+ 04-07-1998
+ 04-08-1998
+ 04-09-1998
+ 04-10-1998
+ 04-11-1998
+ 04-12-1998
+ 04-13-1998
+ 04-14-1998
+ 04-15-1998
+ 04-16-1998
+ 04-17-1998
+ 04-18-1998
+ 04-19-1998
+ 04-20-1998
+ 04-21-1998
+ 04-22-1998
+ 04-23-1998
+ 04-24-1998
+ 04-25-1998
+ 04-26-1998
+ 04-27-1998
+ 04-28-1998
+ 04-29-1998
+ 04-30-1998
+ 05-01-1998
+ 05-02-1998
+ 05-03-1998
+ 05-04-1998
+ 05-05-1998
+ 05-06-1998
+ 05-07-1998
+ 05-08-1998
+ 05-09-1998
+ 05-10-1998
+ 05-11-1998
+ 05-12-1998
+ 05-13-1998
+ 05-14-1998
+ 05-15-1998
+ 05-16-1998
+ 05-17-1998
+ 05-18-1998
+ 05-19-1998
+ 05-20-1998
+ 05-21-1998
+ 05-22-1998
+ 05-23-1998
+ 05-24-1998
+ 05-25-1998
+ 05-26-1998
+ 05-27-1998
+ 05-28-1998
+ 05-29-1998
+ 05-30-1998
+ 05-31-1998
+ 06-01-1998
+ 06-02-1998
+ 06-03-1998
+ 06-04-1998
+ 06-05-1998
+ 06-06-1998
+ 06-07-1998
+ 06-08-1998
+ 06-09-1998
+ 06-10-1998
+ 06-11-1998
+ 06-12-1998
+ 06-13-1998
+ 06-14-1998
+ 06-15-1998
+ 06-16-1998
+ 06-17-1998
+ 06-18-1998
+ 06-19-1998
+ 06-20-1998
+ 06-21-1998
+ 06-22-1998
+ 06-23-1998
+ 06-24-1998
+ 06-25-1998
+ 06-26-1998
+ 06-27-1998
+ 06-28-1998
+ 06-29-1998
+ 06-30-1998
+ 07-01-1998
+ 07-02-1998
+ 07-03-1998
+ 07-04-1998
+ 07-05-1998
+ 07-06-1998
+ 07-07-1998
+ 07-08-1998
+ 07-09-1998
+ 07-10-1998
+ 07-11-1998
+ 07-12-1998
+ 07-13-1998
+ 07-14-1998
+ 07-15-1998
+ 07-16-1998
+ 07-17-1998
+ 07-18-1998
+ 07-19-1998
+ 07-20-1998
+ 07-21-1998
+ 07-22-1998
+ 07-23-1998
+ 07-24-1998
+ 07-25-1998
+ 07-26-1998
+ 07-27-1998
+ 07-28-1998
+ 07-29-1998
+ 07-30-1998
+ 07-31-1998
+ 08-01-1998
+ 08-02-1998
+ 08-03-1998
+ 08-04-1998
+ 08-05-1998
+ 08-06-1998
+ 08-07-1998
+ 08-08-1998
+ 08-09-1998
+ 08-10-1998
+ 08-11-1998
+ 08-12-1998
+ 08-13-1998
+ 08-14-1998
+ 08-15-1998
+ 08-16-1998
+ 08-17-1998
+ 08-18-1998
+ 08-19-1998
+ 08-20-1998
+ 08-21-1998
+ 08-22-1998
+ 08-23-1998
+ 08-24-1998
+ 08-25-1998
+ 08-26-1998
+ 08-27-1998
+ 08-28-1998
+ 08-29-1998
+ 08-30-1998
+ 08-31-1998
+ 09-01-1998
+ 09-02-1998
+ 09-03-1998
+ 09-04-1998
+ 09-05-1998
+ 09-06-1998
+ 09-07-1998
+ 09-08-1998
+ 09-09-1998
+ 09-10-1998
+ 09-11-1998
+ 09-12-1998
+ 09-13-1998
+ 09-14-1998
+ 09-15-1998
+ 09-16-1998
+ 09-17-1998
+ 09-18-1998
+ 09-19-1998
+ 09-20-1998
+ 09-21-1998
+ 09-22-1998
+ 09-23-1998
+ 09-24-1998
+ 09-25-1998
+ 09-26-1998
+ 09-27-1998
+ 09-28-1998
+ 09-29-1998
+ 09-30-1998
+ 10-01-1998
+ 10-02-1998
+ 10-03-1998
+ 10-04-1998
+ 10-05-1998
+ 10-06-1998
+ 10-07-1998
+ 10-08-1998
+ 10-09-1998
+ 10-10-1998
+ 10-11-1998
+ 10-12-1998
+ 10-13-1998
+ 10-14-1998
+ 10-15-1998
+ 10-16-1998
+ 10-17-1998
+ 10-18-1998
+ 10-19-1998
+ 10-20-1998
+ 10-21-1998
+ 10-22-1998
+ 10-23-1998
+ 10-24-1998
+ 10-25-1998
+ 10-26-1998
+ 10-27-1998
+ 10-28-1998
+ 10-29-1998
+ 10-30-1998
+ 10-31-1998
+ 11-01-1998
+ 11-02-1998
+ 11-03-1998
+ 11-04-1998
+ 11-05-1998
+ 11-06-1998
+ 11-07-1998
+ 11-08-1998
+ 11-09-1998
+ 11-10-1998
+ 11-11-1998
+ 11-12-1998
+ 11-13-1998
+ 11-14-1998
+ 11-15-1998
+ 11-16-1998
+ 11-17-1998
+ 11-18-1998
+ 11-19-1998
+ 11-20-1998
+ 11-21-1998
+ 11-22-1998
+ 11-23-1998
+ 11-24-1998
+ 11-25-1998
+ 11-26-1998
+ 11-27-1998
+ 11-28-1998
+ 11-29-1998
+ 11-30-1998
+ 12-01-1998
+ 12-02-1998
+ 12-03-1998
+ 12-04-1998
+ 12-05-1998
+ 12-06-1998
+ 12-07-1998
+ 12-08-1998
+ 12-09-1998
+ 12-10-1998
+ 12-11-1998
+ 12-12-1998
+ 12-13-1998
+ 12-14-1998
+ 12-15-1998
+ 12-16-1998
+ 12-17-1998
+ 12-18-1998
+ 12-19-1998
+ 12-20-1998
+ 12-21-1998
+ 12-22-1998
+ 12-23-1998
+ 12-24-1998
+ 12-25-1998
+ 12-26-1998
+ 12-27-1998
+ 12-28-1998
+ 12-29-1998
+ 12-30-1998
+ 12-31-1998
+ 01-01-1999
+ 01-02-1999
+ 01-03-1999
+ 01-04-1999
+ 01-05-1999
+ 01-06-1999
+ 01-07-1999
+ 01-08-1999
+ 01-09-1999
+ 01-10-1999
+ 01-11-1999
+ 01-12-1999
+ 01-13-1999
+ 01-14-1999
+ 01-15-1999
+ 01-16-1999
+ 01-17-1999
+ 01-18-1999
+ 01-19-1999
+ 01-20-1999
+ 01-21-1999
+ 01-22-1999
+ 01-23-1999
+ 01-24-1999
+ 01-25-1999
+ 01-26-1999
+ 01-27-1999
+ 01-28-1999
+ 01-29-1999
+ 01-30-1999
+ 01-31-1999
+ 02-01-1999
+ 02-02-1999
+ 02-03-1999
+ 02-04-1999
+ 02-05-1999
+ 02-06-1999
+ 02-07-1999
+ 02-08-1999
+ 02-09-1999
+ 02-10-1999
+ 02-11-1999
+ 02-12-1999
+ 02-13-1999
+ 02-14-1999
+ 02-15-1999
+ 02-16-1999
+ 02-17-1999
+ 02-18-1999
+ 02-19-1999
+ 02-20-1999
+ 02-21-1999
+ 02-22-1999
+ 02-23-1999
+ 02-24-1999
+ 02-25-1999
+ 02-26-1999
+ 02-27-1999
+ 02-28-1999
+ 03-01-1999
+ 03-02-1999
+ 03-03-1999
+ 03-04-1999
+ 03-05-1999
+ 03-06-1999
+ 03-07-1999
+ 03-08-1999
+ 03-09-1999
+ 03-10-1999
+ 03-11-1999
+ 03-12-1999
+ 03-13-1999
+ 03-14-1999
+ 03-15-1999
+ 03-16-1999
+ 03-17-1999
+ 03-18-1999
+ 03-19-1999
+ 03-20-1999
+ 03-21-1999
+ 03-22-1999
+ 03-23-1999
+ 03-24-1999
+ 03-25-1999
+ 03-26-1999
+ 03-27-1999
+ 03-28-1999
+ 03-29-1999
+ 03-30-1999
+ 03-31-1999
+ 04-01-1999
+ 04-02-1999
+ 04-03-1999
+ 04-04-1999
+ 04-05-1999
+ 04-06-1999
+ 04-07-1999
+ 04-08-1999
+ 04-09-1999
+ 04-10-1999
+ 04-11-1999
+ 04-12-1999
+ 04-13-1999
+ 04-14-1999
+ 04-15-1999
+ 04-16-1999
+ 04-17-1999
+ 04-18-1999
+ 04-19-1999
+ 04-20-1999
+ 04-21-1999
+ 04-22-1999
+ 04-23-1999
+ 04-24-1999
+ 04-25-1999
+ 04-26-1999
+ 04-27-1999
+ 04-28-1999
+ 04-29-1999
+ 04-30-1999
+ 05-01-1999
+ 05-02-1999
+ 05-03-1999
+ 05-04-1999
+ 05-05-1999
+ 05-06-1999
+ 05-07-1999
+ 05-08-1999
+ 05-09-1999
+ 05-10-1999
+ 05-11-1999
+ 05-12-1999
+ 05-13-1999
+ 05-14-1999
+ 05-15-1999
+ 05-16-1999
+ 05-17-1999
+ 05-18-1999
+ 05-19-1999
+ 05-20-1999
+ 05-21-1999
+ 05-22-1999
+ 05-23-1999
+ 05-24-1999
+ 05-25-1999
+ 05-26-1999
+ 05-27-1999
+ 05-28-1999
+ 05-29-1999
+ 05-30-1999
+ 05-31-1999
+ 06-01-1999
+ 06-02-1999
+ 06-03-1999
+ 06-04-1999
+ 06-05-1999
+ 06-06-1999
+ 06-07-1999
+ 06-08-1999
+ 06-09-1999
+ 06-10-1999
+ 06-11-1999
+ 06-12-1999
+ 06-13-1999
+ 06-14-1999
+ 06-15-1999
+ 06-16-1999
+ 06-17-1999
+ 06-18-1999
+ 06-19-1999
+ 06-20-1999
+ 06-21-1999
+ 06-22-1999
+ 06-23-1999
+ 06-24-1999
+ 06-25-1999
+ 06-26-1999
+ 06-27-1999
+ 06-28-1999
+ 06-29-1999
+ 06-30-1999
+ 07-01-1999
+ 07-02-1999
+ 07-03-1999
+ 07-04-1999
+ 07-05-1999
+ 07-06-1999
+ 07-07-1999
+ 07-08-1999
+ 07-09-1999
+ 07-10-1999
+ 07-11-1999
+ 07-12-1999
+ 07-13-1999
+ 07-14-1999
+ 07-15-1999
+ 07-16-1999
+ 07-17-1999
+ 07-18-1999
+ 07-19-1999
+ 07-20-1999
+ 07-21-1999
+ 07-22-1999
+ 07-23-1999
+ 07-24-1999
+ 07-25-1999
+ 07-26-1999
+ 07-27-1999
+ 07-28-1999
+ 07-29-1999
+ 07-30-1999
+ 07-31-1999
+ 08-01-1999
+ 08-02-1999
+ 08-03-1999
+ 08-04-1999
+ 08-05-1999
+ 08-06-1999
+ 08-07-1999
+ 08-08-1999
+ 08-09-1999
+ 08-10-1999
+ 08-11-1999
+ 08-12-1999
+ 08-13-1999
+ 08-14-1999
+ 08-15-1999
+ 08-16-1999
+ 08-17-1999
+ 08-18-1999
+ 08-19-1999
+ 08-20-1999
+ 08-21-1999
+ 08-22-1999
+ 08-23-1999
+ 08-24-1999
+ 08-25-1999
+ 08-26-1999
+ 08-27-1999
+ 08-28-1999
+ 08-29-1999
+ 08-30-1999
+ 08-31-1999
+ 09-01-1999
+ 09-02-1999
+ 09-03-1999
+ 09-04-1999
+ 09-05-1999
+ 09-06-1999
+ 09-07-1999
+ 09-08-1999
+ 09-09-1999
+ 09-10-1999
+ 09-11-1999
+ 09-12-1999
+ 09-13-1999
+ 09-14-1999
+ 09-15-1999
+ 09-16-1999
+ 09-17-1999
+ 09-18-1999
+ 09-19-1999
+ 09-20-1999
+ 09-21-1999
+ 09-22-1999
+ 09-23-1999
+ 09-24-1999
+ 09-25-1999
+ 09-26-1999
+ 09-27-1999
+ 09-28-1999
+ 09-29-1999
+ 09-30-1999
+ 10-01-1999
+ 10-02-1999
+ 10-03-1999
+ 10-04-1999
+ 10-05-1999
+ 10-06-1999
+ 10-07-1999
+ 10-08-1999
+ 10-09-1999
+ 10-10-1999
+ 10-11-1999
+ 10-12-1999
+ 10-13-1999
+ 10-14-1999
+ 10-15-1999
+ 10-16-1999
+ 10-17-1999
+ 10-18-1999
+ 10-19-1999
+ 10-20-1999
+ 10-21-1999
+ 10-22-1999
+ 10-23-1999
+ 10-24-1999
+ 10-25-1999
+ 10-26-1999
+ 10-27-1999
+ 10-28-1999
+ 10-29-1999
+ 10-30-1999
+ 10-31-1999
+ 11-01-1999
+ 11-02-1999
+ 11-03-1999
+ 11-04-1999
+ 11-05-1999
+ 11-06-1999
+ 11-07-1999
+ 11-08-1999
+ 11-09-1999
+ 11-10-1999
+ 11-11-1999
+ 11-12-1999
+ 11-13-1999
+ 11-14-1999
+ 11-15-1999
+ 11-16-1999
+ 11-17-1999
+ 11-18-1999
+ 11-19-1999
+ 11-20-1999
+ 11-21-1999
+ 11-22-1999
+ 11-23-1999
+ 11-24-1999
+ 11-25-1999
+ 11-26-1999
+ 11-27-1999
+ 11-28-1999
+ 11-29-1999
+ 11-30-1999
+ 12-01-1999
+ 12-02-1999
+ 12-03-1999
+ 12-04-1999
+ 12-05-1999
+ 12-06-1999
+ 12-07-1999
+ 12-08-1999
+ 12-09-1999
+ 12-10-1999
+ 12-11-1999
+ 12-12-1999
+ 12-13-1999
+ 12-14-1999
+ 12-15-1999
+ 12-16-1999
+ 12-17-1999
+ 12-18-1999
+ 12-19-1999
+ 12-20-1999
+ 12-21-1999
+ 12-22-1999
+ 12-23-1999
+ 12-24-1999
+ 12-25-1999
+ 12-26-1999
+ 12-27-1999
+ 12-28-1999
+ 12-29-1999
+ 12-30-1999
+ 12-31-1999
+ 01-01-2000
+ 01-02-2000
+ 01-03-2000
+ 01-04-2000
+ 01-05-2000
+ 01-06-2000
+ 01-07-2000
+ 01-08-2000
+ 01-09-2000
+ 01-10-2000
+ 01-11-2000
+ 01-12-2000
+ 01-13-2000
+ 01-14-2000
+ 01-15-2000
+ 01-16-2000
+ 01-17-2000
+ 01-18-2000
+ 01-19-2000
+ 01-20-2000
+ 01-21-2000
+ 01-22-2000
+ 01-23-2000
+ 01-24-2000
+ 01-25-2000
+ 01-26-2000
+ 01-27-2000
+ 01-28-2000
+ 01-29-2000
+ 01-30-2000
+ 01-31-2000
+ 02-01-2000
+ 02-02-2000
+ 02-03-2000
+ 02-04-2000
+ 02-05-2000
+ 02-06-2000
+ 02-07-2000
+ 02-08-2000
+ 02-09-2000
+ 02-10-2000
+ 02-11-2000
+ 02-12-2000
+ 02-13-2000
+ 02-14-2000
+ 02-15-2000
+ 02-16-2000
+ 02-17-2000
+ 02-18-2000
+ 02-19-2000
+ 02-20-2000
+ 02-21-2000
+ 02-22-2000
+ 02-23-2000
+ 02-24-2000
+ 02-25-2000
+ 02-26-2000
+ 02-27-2000
+ 02-28-2000
+ 02-29-2000
+ 03-01-2000
+ 03-02-2000
+ 03-03-2000
+ 03-04-2000
+ 03-05-2000
+ 03-06-2000
+ 03-07-2000
+ 03-08-2000
+ 03-09-2000
+ 03-10-2000
+ 03-11-2000
+ 03-12-2000
+ 03-13-2000
+ 03-14-2000
+ 03-15-2000
+ 03-16-2000
+ 03-17-2000
+ 03-18-2000
+ 03-19-2000
+ 03-20-2000
+ 03-21-2000
+ 03-22-2000
+ 03-23-2000
+ 03-24-2000
+ 03-25-2000
+ 03-26-2000
+ 03-27-2000
+ 03-28-2000
+ 03-29-2000
+ 03-30-2000
+ 03-31-2000
+ 04-01-2000
+ 04-02-2000
+ 04-03-2000
+ 04-04-2000
+ 04-05-2000
+ 04-06-2000
+ 04-07-2000
+ 04-08-2000
+ 04-09-2000
+ 04-10-2000
+ 04-11-2000
+ 04-12-2000
+ 04-13-2000
+ 04-14-2000
+ 04-15-2000
+ 04-16-2000
+ 04-17-2000
+ 04-18-2000
+ 04-19-2000
+ 04-20-2000
+ 04-21-2000
+ 04-22-2000
+ 04-23-2000
+ 04-24-2000
+ 04-25-2000
+ 04-26-2000
+ 04-27-2000
+ 04-28-2000
+ 04-29-2000
+ 04-30-2000
+ 05-01-2000
+ 05-02-2000
+ 05-03-2000
+ 05-04-2000
+ 05-05-2000
+ 05-06-2000
+ 05-07-2000
+ 05-08-2000
+ 05-09-2000
+ 05-10-2000
+ 05-11-2000
+ 05-12-2000
+ 05-13-2000
+ 05-14-2000
+ 05-15-2000
+ 05-16-2000
+ 05-17-2000
+ 05-18-2000
+ 05-19-2000
+ 05-20-2000
+ 05-21-2000
+ 05-22-2000
+ 05-23-2000
+ 05-24-2000
+ 05-25-2000
+ 05-26-2000
+ 05-27-2000
+ 05-28-2000
+ 05-29-2000
+ 05-30-2000
+ 05-31-2000
+ 06-01-2000
+ 06-02-2000
+ 06-03-2000
+ 06-04-2000
+ 06-05-2000
+ 06-06-2000
+ 06-07-2000
+ 06-08-2000
+ 06-09-2000
+ 06-10-2000
+ 06-11-2000
+ 06-12-2000
+ 06-13-2000
+ 06-14-2000
+ 06-15-2000
+ 06-16-2000
+ 06-17-2000
+ 06-18-2000
+ 06-19-2000
+ 06-20-2000
+ 06-21-2000
+ 06-22-2000
+ 06-23-2000
+ 06-24-2000
+ 06-25-2000
+ 06-26-2000
+ 06-27-2000
+ 06-28-2000
+ 06-29-2000
+ 06-30-2000
+ 07-01-2000
+ 07-02-2000
+ 07-03-2000
+ 07-04-2000
+ 07-05-2000
+ 07-06-2000
+ 07-07-2000
+ 07-08-2000
+ 07-09-2000
+ 07-10-2000
+ 07-11-2000
+ 07-12-2000
+ 07-13-2000
+ 07-14-2000
+ 07-15-2000
+ 07-16-2000
+ 07-17-2000
+ 07-18-2000
+ 07-19-2000
+ 07-20-2000
+ 07-21-2000
+ 07-22-2000
+ 07-23-2000
+ 07-24-2000
+ 07-25-2000
+ 07-26-2000
+ 07-27-2000
+ 07-28-2000
+ 07-29-2000
+ 07-30-2000
+ 07-31-2000
+ 08-01-2000
+ 08-02-2000
+ 08-03-2000
+ 08-04-2000
+ 08-05-2000
+ 08-06-2000
+ 08-07-2000
+ 08-08-2000
+ 08-09-2000
+ 08-10-2000
+ 08-11-2000
+ 08-12-2000
+ 08-13-2000
+ 08-14-2000
+ 08-15-2000
+ 08-16-2000
+ 08-17-2000
+ 08-18-2000
+ 08-19-2000
+ 08-20-2000
+ 08-21-2000
+ 08-22-2000
+ 08-23-2000
+ 08-24-2000
+ 08-25-2000
+ 08-26-2000
+ 08-27-2000
+ 08-28-2000
+ 08-29-2000
+ 08-30-2000
+ 08-31-2000
+ 09-01-2000
+ 09-02-2000
+ 09-03-2000
+ 09-04-2000
+ 09-05-2000
+ 09-06-2000
+ 09-07-2000
+ 09-08-2000
+ 09-09-2000
+ 09-10-2000
+ 09-11-2000
+ 09-12-2000
+ 09-13-2000
+ 09-14-2000
+ 09-15-2000
+ 09-16-2000
+ 09-17-2000
+ 09-18-2000
+ 09-19-2000
+ 09-20-2000
+ 09-21-2000
+ 09-22-2000
+ 09-23-2000
+ 09-24-2000
+ 09-25-2000
+ 09-26-2000
+ 09-27-2000
+ 09-28-2000
+ 09-29-2000
+ 09-30-2000
+ 10-01-2000
+ 10-02-2000
+ 10-03-2000
+ 10-04-2000
+ 10-05-2000
+ 10-06-2000
+ 10-07-2000
+ 10-08-2000
+ 10-09-2000
+ 10-10-2000
+ 10-11-2000
+ 10-12-2000
+ 10-13-2000
+ 10-14-2000
+ 10-15-2000
+ 10-16-2000
+ 10-17-2000
+ 10-18-2000
+ 10-19-2000
+ 10-20-2000
+ 10-21-2000
+ 10-22-2000
+ 10-23-2000
+ 10-24-2000
+ 10-25-2000
+ 10-26-2000
+ 10-27-2000
+ 10-28-2000
+ 10-29-2000
+ 10-30-2000
+ 10-31-2000
+ 11-01-2000
+ 11-02-2000
+ 11-03-2000
+ 11-04-2000
+ 11-05-2000
+ 11-06-2000
+ 11-07-2000
+ 11-08-2000
+ 11-09-2000
+ 11-10-2000
+ 11-11-2000
+ 11-12-2000
+ 11-13-2000
+ 11-14-2000
+ 11-15-2000
+ 11-16-2000
+ 11-17-2000
+ 11-18-2000
+ 11-19-2000
+ 11-20-2000
+ 11-21-2000
+ 11-22-2000
+ 11-23-2000
+ 11-24-2000
+ 11-25-2000
+ 11-26-2000
+ 11-27-2000
+ 11-28-2000
+ 11-29-2000
+ 11-30-2000
+ 12-01-2000
+ 12-02-2000
+ 12-03-2000
+ 12-04-2000
+ 12-05-2000
+ 12-06-2000
+ 12-07-2000
+ 12-08-2000
+ 12-09-2000
+ 12-10-2000
+ 12-11-2000
+ 12-12-2000
+ 12-13-2000
+ 12-14-2000
+ 12-15-2000
+ 12-16-2000
+ 12-17-2000
+ 12-18-2000
+ 12-19-2000
+ 12-20-2000
+ 12-21-2000
+ 12-22-2000
+ 12-23-2000
+ 12-24-2000
+ 12-25-2000
+ 12-26-2000
+ 12-27-2000
+ 12-28-2000
+ 12-29-2000
+ 12-30-2000
+ 12-31-2000
+ 01-01-2001
+ 01-02-2001
+ 01-03-2001
+ 01-04-2001
+ 01-05-2001
+ 01-06-2001
+ 01-07-2001
+ 01-08-2001
+ 01-09-2001
+ 01-10-2001
+ 01-11-2001
+ 01-12-2001
+ 01-13-2001
+ 01-14-2001
+ 01-15-2001
+ 01-16-2001
+ 01-17-2001
+ 01-18-2001
+ 01-19-2001
+ 01-20-2001
+ 01-21-2001
+ 01-22-2001
+ 01-23-2001
+ 01-24-2001
+ 01-25-2001
+ 01-26-2001
+ 01-27-2001
+ 01-28-2001
+ 01-29-2001
+ 01-30-2001
+ 01-31-2001
+ 02-01-2001
+ 02-02-2001
+ 02-03-2001
+ 02-04-2001
+ 02-05-2001
+ 02-06-2001
+ 02-07-2001
+ 02-08-2001
+ 02-09-2001
+ 02-10-2001
+ 02-11-2001
+ 02-12-2001
+ 02-13-2001
+ 02-14-2001
+ 02-15-2001
+ 02-16-2001
+ 02-17-2001
+ 02-18-2001
+ 02-19-2001
+ 02-20-2001
+ 02-21-2001
+ 02-22-2001
+ 02-23-2001
+ 02-24-2001
+ 02-25-2001
+ 02-26-2001
+ 02-27-2001
+ 02-28-2001
+ 03-01-2001
+ 03-02-2001
+ 03-03-2001
+ 03-04-2001
+ 03-05-2001
+ 03-06-2001
+ 03-07-2001
+ 03-08-2001
+ 03-09-2001
+ 03-10-2001
+ 03-11-2001
+ 03-12-2001
+ 03-13-2001
+ 03-14-2001
+ 03-15-2001
+ 03-16-2001
+ 03-17-2001
+ 03-18-2001
+ 03-19-2001
+ 03-20-2001
+ 03-21-2001
+ 03-22-2001
+ 03-23-2001
+ 03-24-2001
+ 03-25-2001
+ 03-26-2001
+ 03-27-2001
+ 03-28-2001
+ 03-29-2001
+ 03-30-2001
+ 03-31-2001
+ 04-01-2001
+ 04-02-2001
+ 04-03-2001
+ 04-04-2001
+ 04-05-2001
+ 04-06-2001
+ 04-07-2001
+ 04-08-2001
+ 04-09-2001
+ 04-10-2001
+ 04-11-2001
+ 04-12-2001
+ 04-13-2001
+ 04-14-2001
+ 04-15-2001
+ 04-16-2001
+ 04-17-2001
+ 04-18-2001
+ 04-19-2001
+ 04-20-2001
+ 04-21-2001
+ 04-22-2001
+ 04-23-2001
+ 04-24-2001
+ 04-25-2001
+ 04-26-2001
+ 04-27-2001
+ 04-28-2001
+ 04-29-2001
+ 04-30-2001
+ 05-01-2001
+ 05-02-2001
+ 05-03-2001
+ 05-04-2001
+ 05-05-2001
+ 05-06-2001
+ 05-07-2001
+ 05-08-2001
+ 05-09-2001
+ 05-10-2001
+ 05-11-2001
+ 05-12-2001
+ 05-13-2001
+ 05-14-2001
+ 05-15-2001
+ 05-16-2001
+ 05-17-2001
+ 05-18-2001
+ 05-19-2001
+ 05-20-2001
+ 05-21-2001
+ 05-22-2001
+ 05-23-2001
+ 05-24-2001
+ 05-25-2001
+ 05-26-2001
+ 05-27-2001
+ 05-28-2001
+ 05-29-2001
+ 05-30-2001
+ 05-31-2001
+ 06-01-2001
+ 06-02-2001
+ 06-03-2001
+ 06-04-2001
+ 06-05-2001
+ 06-06-2001
+ 06-07-2001
+ 06-08-2001
+ 06-09-2001
+ 06-10-2001
+ 06-11-2001
+ 06-12-2001
+ 06-13-2001
+ 06-14-2001
+ 06-15-2001
+ 06-16-2001
+ 06-17-2001
+ 06-18-2001
+ 06-19-2001
+ 06-20-2001
+ 06-21-2001
+ 06-22-2001
+ 06-23-2001
+ 06-24-2001
+ 06-25-2001
+ 06-26-2001
+ 06-27-2001
+ 06-28-2001
+ 06-29-2001
+ 06-30-2001
+ 07-01-2001
+ 07-02-2001
+ 07-03-2001
+ 07-04-2001
+ 07-05-2001
+ 07-06-2001
+ 07-07-2001
+ 07-08-2001
+ 07-09-2001
+ 07-10-2001
+ 07-11-2001
+ 07-12-2001
+ 07-13-2001
+ 07-14-2001
+ 07-15-2001
+ 07-16-2001
+ 07-17-2001
+ 07-18-2001
+ 07-19-2001
+ 07-20-2001
+ 07-21-2001
+ 07-22-2001
+ 07-23-2001
+ 07-24-2001
+ 07-25-2001
+ 07-26-2001
+ 07-27-2001
+ 07-28-2001
+ 07-29-2001
+ 07-30-2001
+ 07-31-2001
+ 08-01-2001
+ 08-02-2001
+ 08-03-2001
+ 08-04-2001
+ 08-05-2001
+ 08-06-2001
+ 08-07-2001
+ 08-08-2001
+ 08-09-2001
+ 08-10-2001
+ 08-11-2001
+ 08-12-2001
+ 08-13-2001
+ 08-14-2001
+ 08-15-2001
+ 08-16-2001
+ 08-17-2001
+ 08-18-2001
+ 08-19-2001
+ 08-20-2001
+ 08-21-2001
+ 08-22-2001
+ 08-23-2001
+ 08-24-2001
+ 08-25-2001
+ 08-26-2001
+ 08-27-2001
+ 08-28-2001
+ 08-29-2001
+ 08-30-2001
+ 08-31-2001
+ 09-01-2001
+ 09-02-2001
+ 09-03-2001
+ 09-04-2001
+ 09-05-2001
+ 09-06-2001
+ 09-07-2001
+ 09-08-2001
+ 09-09-2001
+ 09-10-2001
+ 09-11-2001
+ 09-12-2001
+ 09-13-2001
+ 09-14-2001
+ 09-15-2001
+ 09-16-2001
+ 09-17-2001
+ 09-18-2001
+ 09-19-2001
+ 09-20-2001
+ 09-21-2001
+ 09-22-2001
+ 09-23-2001
+ 09-24-2001
+ 09-25-2001
+ 09-26-2001
+ 09-27-2001
+ 09-28-2001
+ 09-29-2001
+ 09-30-2001
+ 10-01-2001
+ 10-02-2001
+ 10-03-2001
+ 10-04-2001
+ 10-05-2001
+ 10-06-2001
+ 10-07-2001
+ 10-08-2001
+ 10-09-2001
+ 10-10-2001
+ 10-11-2001
+ 10-12-2001
+ 10-13-2001
+ 10-14-2001
+ 10-15-2001
+ 10-16-2001
+ 10-17-2001
+ 10-18-2001
+ 10-19-2001
+ 10-20-2001
+ 10-21-2001
+ 10-22-2001
+ 10-23-2001
+ 10-24-2001
+ 10-25-2001
+ 10-26-2001
+ 10-27-2001
+ 10-28-2001
+ 10-29-2001
+ 10-30-2001
+ 10-31-2001
+ 11-01-2001
+ 11-02-2001
+ 11-03-2001
+ 11-04-2001
+ 11-05-2001
+ 11-06-2001
+ 11-07-2001
+ 11-08-2001
+ 11-09-2001
+ 11-10-2001
+ 11-11-2001
+ 11-12-2001
+ 11-13-2001
+ 11-14-2001
+ 11-15-2001
+ 11-16-2001
+ 11-17-2001
+ 11-18-2001
+ 11-19-2001
+ 11-20-2001
+ 11-21-2001
+ 11-22-2001
+ 11-23-2001
+ 11-24-2001
+ 11-25-2001
+ 11-26-2001
+ 11-27-2001
+ 11-28-2001
+ 11-29-2001
+ 11-30-2001
+ 12-01-2001
+ 12-02-2001
+ 12-03-2001
+ 12-04-2001
+ 12-05-2001
+ 12-06-2001
+ 12-07-2001
+ 12-08-2001
+ 12-09-2001
+ 12-10-2001
+ 12-11-2001
+ 12-12-2001
+ 12-13-2001
+ 12-14-2001
+ 12-15-2001
+ 12-16-2001
+ 12-17-2001
+ 12-18-2001
+ 12-19-2001
+ 12-20-2001
+ 12-21-2001
+ 12-22-2001
+ 12-23-2001
+ 12-24-2001
+ 12-25-2001
+ 12-26-2001
+ 12-27-2001
+ 12-28-2001
+ 12-29-2001
+ 12-30-2001
+ 12-31-2001
+ 01-01-2002
+ 01-02-2002
+ 01-03-2002
+ 01-04-2002
+ 01-05-2002
+ 01-06-2002
+ 01-07-2002
+ 01-08-2002
+ 01-09-2002
+ 01-10-2002
+ 01-11-2002
+ 01-12-2002
+ 01-13-2002
+ 01-14-2002
+ 01-15-2002
+ 01-16-2002
+ 01-17-2002
+ 01-18-2002
+ 01-19-2002
+ 01-20-2002
+ 01-21-2002
+ 01-22-2002
+ 01-23-2002
+ 01-24-2002
+ 01-25-2002
+ 01-26-2002
+ 01-27-2002
+ 01-28-2002
+ 01-29-2002
+ 01-30-2002
+ 01-31-2002
+ 02-01-2002
+ 02-02-2002
+ 02-03-2002
+ 02-04-2002
+ 02-05-2002
+ 02-06-2002
+ 02-07-2002
+ 02-08-2002
+ 02-09-2002
+ 02-10-2002
+ 02-11-2002
+ 02-12-2002
+ 02-13-2002
+ 02-14-2002
+ 02-15-2002
+ 02-16-2002
+ 02-17-2002
+ 02-18-2002
+ 02-19-2002
+ 02-20-2002
+ 02-21-2002
+ 02-22-2002
+ 02-23-2002
+ 02-24-2002
+ 02-25-2002
+ 02-26-2002
+ 02-27-2002
+ 02-28-2002
+ 03-01-2002
+ 03-02-2002
+ 03-03-2002
+ 03-04-2002
+ 03-05-2002
+ 03-06-2002
+ 03-07-2002
+ 03-08-2002
+ 03-09-2002
+ 03-10-2002
+ 03-11-2002
+ 03-12-2002
+ 03-13-2002
+ 03-14-2002
+ 03-15-2002
+ 03-16-2002
+ 03-17-2002
+ 03-18-2002
+ 03-19-2002
+ 03-20-2002
+ 03-21-2002
+ 03-22-2002
+ 03-23-2002
+ 03-24-2002
+ 03-25-2002
+ 03-26-2002
+ 03-27-2002
+ 03-28-2002
+ 03-29-2002
+ 03-30-2002
+ 03-31-2002
+ 04-01-2002
+ 04-02-2002
+ 04-03-2002
+ 04-04-2002
+ 04-05-2002
+ 04-06-2002
+ 04-07-2002
+ 04-08-2002
+ 04-09-2002
+ 04-10-2002
+ 04-11-2002
+ 04-12-2002
+ 04-13-2002
+ 04-14-2002
+ 04-15-2002
+ 04-16-2002
+ 04-17-2002
+ 04-18-2002
+ 04-19-2002
+ 04-20-2002
+ 04-21-2002
+ 04-22-2002
+ 04-23-2002
+ 04-24-2002
+ 04-25-2002
+ 04-26-2002
+ 04-27-2002
+ 04-28-2002
+ 04-29-2002
+ 04-30-2002
+ 05-01-2002
+ 05-02-2002
+ 05-03-2002
+ 05-04-2002
+ 05-05-2002
+ 05-06-2002
+ 05-07-2002
+ 05-08-2002
+ 05-09-2002
+ 05-10-2002
+ 05-11-2002
+ 05-12-2002
+ 05-13-2002
+ 05-14-2002
+ 05-15-2002
+ 05-16-2002
+ 05-17-2002
+ 05-18-2002
+ 05-19-2002
+ 05-20-2002
+ 05-21-2002
+ 05-22-2002
+ 05-23-2002
+ 05-24-2002
+ 05-25-2002
+ 05-26-2002
+ 05-27-2002
+ 05-28-2002
+ 05-29-2002
+ 05-30-2002
+ 05-31-2002
+ 06-01-2002
+ 06-02-2002
+ 06-03-2002
+ 06-04-2002
+ 06-05-2002
+ 06-06-2002
+ 06-07-2002
+ 06-08-2002
+ 06-09-2002
+ 06-10-2002
+ 06-11-2002
+ 06-12-2002
+ 06-13-2002
+ 06-14-2002
+ 06-15-2002
+ 06-16-2002
+ 06-17-2002
+ 06-18-2002
+ 06-19-2002
+ 06-20-2002
+ 06-21-2002
+ 06-22-2002
+ 06-23-2002
+ 06-24-2002
+ 06-25-2002
+ 06-26-2002
+ 06-27-2002
+ 06-28-2002
+ 06-29-2002
+ 06-30-2002
+ 07-01-2002
+ 07-02-2002
+ 07-03-2002
+ 07-04-2002
+ 07-05-2002
+ 07-06-2002
+ 07-07-2002
+ 07-08-2002
+ 07-09-2002
+ 07-10-2002
+ 07-11-2002
+ 07-12-2002
+ 07-13-2002
+ 07-14-2002
+ 07-15-2002
+ 07-16-2002
+ 07-17-2002
+ 07-18-2002
+ 07-19-2002
+ 07-20-2002
+ 07-21-2002
+ 07-22-2002
+ 07-23-2002
+ 07-24-2002
+ 07-25-2002
+ 07-26-2002
+ 07-27-2002
+ 07-28-2002
+ 07-29-2002
+ 07-30-2002
+ 07-31-2002
+ 08-01-2002
+ 08-02-2002
+ 08-03-2002
+ 08-04-2002
+ 08-05-2002
+ 08-06-2002
+ 08-07-2002
+ 08-08-2002
+ 08-09-2002
+ 08-10-2002
+ 08-11-2002
+ 08-12-2002
+ 08-13-2002
+ 08-14-2002
+ 08-15-2002
+ 08-16-2002
+ 08-17-2002
+ 08-18-2002
+ 08-19-2002
+ 08-20-2002
+ 08-21-2002
+ 08-22-2002
+ 08-23-2002
+ 08-24-2002
+ 08-25-2002
+ 08-26-2002
+ 08-27-2002
+ 08-28-2002
+ 08-29-2002
+ 08-30-2002
+ 08-31-2002
+ 09-01-2002
+ 09-02-2002
+ 09-03-2002
+ 09-04-2002
+ 09-05-2002
+ 09-06-2002
+ 09-07-2002
+ 09-08-2002
+ 09-09-2002
+ 09-10-2002
+ 09-11-2002
+ 09-12-2002
+ 09-13-2002
+ 09-14-2002
+ 09-15-2002
+ 09-16-2002
+ 09-17-2002
+ 09-18-2002
+ 09-19-2002
+ 09-20-2002
+ 09-21-2002
+ 09-22-2002
+ 09-23-2002
+ 09-24-2002
+ 09-25-2002
+ 09-26-2002
+ 09-27-2002
+ 09-28-2002
+ 09-29-2002
+ 09-30-2002
+ 10-01-2002
+ 10-02-2002
+ 10-03-2002
+ 10-04-2002
+ 10-05-2002
+ 10-06-2002
+ 10-07-2002
+ 10-08-2002
+ 10-09-2002
+ 10-10-2002
+ 10-11-2002
+ 10-12-2002
+ 10-13-2002
+ 10-14-2002
+ 10-15-2002
+ 10-16-2002
+ 10-17-2002
+ 10-18-2002
+ 10-19-2002
+ 10-20-2002
+ 10-21-2002
+ 10-22-2002
+ 10-23-2002
+ 10-24-2002
+ 10-25-2002
+ 10-26-2002
+ 10-27-2002
+ 10-28-2002
+ 10-29-2002
+ 10-30-2002
+ 10-31-2002
+ 11-01-2002
+ 11-02-2002
+ 11-03-2002
+ 11-04-2002
+ 11-05-2002
+ 11-06-2002
+ 11-07-2002
+ 11-08-2002
+ 11-09-2002
+ 11-10-2002
+ 11-11-2002
+ 11-12-2002
+ 11-13-2002
+ 11-14-2002
+ 11-15-2002
+ 11-16-2002
+ 11-17-2002
+ 11-18-2002
+ 11-19-2002
+ 11-20-2002
+ 11-21-2002
+ 11-22-2002
+ 11-23-2002
+ 11-24-2002
+ 11-25-2002
+ 11-26-2002
+ 11-27-2002
+ 11-28-2002
+ 11-29-2002
+ 11-30-2002
+ 12-01-2002
+ 12-02-2002
+ 12-03-2002
+ 12-04-2002
+ 12-05-2002
+ 12-06-2002
+ 12-07-2002
+ 12-08-2002
+ 12-09-2002
+ 12-10-2002
+ 12-11-2002
+ 12-12-2002
+ 12-13-2002
+ 12-14-2002
+ 12-15-2002
+ 12-16-2002
+ 12-17-2002
+ 12-18-2002
+ 12-19-2002
+ 12-20-2002
+ 12-21-2002
+ 12-22-2002
+ 12-23-2002
+ 12-24-2002
+ 12-25-2002
+ 12-26-2002
+ 12-27-2002
+ 12-28-2002
+ 12-29-2002
+ 12-30-2002
+ 12-31-2002
+ 01-01-2003
+ 01-02-2003
+ 01-03-2003
+ 01-04-2003
+ 01-05-2003
+ 01-06-2003
+ 01-07-2003
+ 01-08-2003
+ 01-09-2003
+ 01-10-2003
+ 01-11-2003
+ 01-12-2003
+ 01-13-2003
+ 01-14-2003
+ 01-15-2003
+ 01-16-2003
+ 01-17-2003
+ 01-18-2003
+ 01-19-2003
+ 01-20-2003
+ 01-21-2003
+ 01-22-2003
+ 01-23-2003
+ 01-24-2003
+ 01-25-2003
+ 01-26-2003
+ 01-27-2003
+ 01-28-2003
+ 01-29-2003
+ 01-30-2003
+ 01-31-2003
+ 02-01-2003
+ 02-02-2003
+ 02-03-2003
+ 02-04-2003
+ 02-05-2003
+ 02-06-2003
+ 02-07-2003
+ 02-08-2003
+ 02-09-2003
+ 02-10-2003
+ 02-11-2003
+ 02-12-2003
+ 02-13-2003
+ 02-14-2003
+ 02-15-2003
+ 02-16-2003
+ 02-17-2003
+ 02-18-2003
+ 02-19-2003
+ 02-20-2003
+ 02-21-2003
+ 02-22-2003
+ 02-23-2003
+ 02-24-2003
+ 02-25-2003
+ 02-26-2003
+ 02-27-2003
+ 02-28-2003
+ 03-01-2003
+ 03-02-2003
+ 03-03-2003
+ 03-04-2003
+ 03-05-2003
+ 03-06-2003
+ 03-07-2003
+ 03-08-2003
+ 03-09-2003
+ 03-10-2003
+ 03-11-2003
+ 03-12-2003
+ 03-13-2003
+ 03-14-2003
+ 03-15-2003
+ 03-16-2003
+ 03-17-2003
+ 03-18-2003
+ 03-19-2003
+ 03-20-2003
+ 03-21-2003
+ 03-22-2003
+ 03-23-2003
+ 03-24-2003
+ 03-25-2003
+ 03-26-2003
+ 03-27-2003
+ 03-28-2003
+ 03-29-2003
+ 03-30-2003
+ 03-31-2003
+ 04-01-2003
+ 04-02-2003
+ 04-03-2003
+ 04-04-2003
+ 04-05-2003
+ 04-06-2003
+ 04-07-2003
+ 04-08-2003
+ 04-09-2003
+ 04-10-2003
+ 04-11-2003
+ 04-12-2003
+ 04-13-2003
+ 04-14-2003
+ 04-15-2003
+ 04-16-2003
+ 04-17-2003
+ 04-18-2003
+ 04-19-2003
+ 04-20-2003
+ 04-21-2003
+ 04-22-2003
+ 04-23-2003
+ 04-24-2003
+ 04-25-2003
+ 04-26-2003
+ 04-27-2003
+ 04-28-2003
+ 04-29-2003
+ 04-30-2003
+ 05-01-2003
+ 05-02-2003
+ 05-03-2003
+ 05-04-2003
+ 05-05-2003
+ 05-06-2003
+ 05-07-2003
+ 05-08-2003
+ 05-09-2003
+ 05-10-2003
+ 05-11-2003
+ 05-12-2003
+ 05-13-2003
+ 05-14-2003
+ 05-15-2003
+ 05-16-2003
+ 05-17-2003
+ 05-18-2003
+ 05-19-2003
+ 05-20-2003
+ 05-21-2003
+ 05-22-2003
+ 05-23-2003
+ 05-24-2003
+ 05-25-2003
+ 05-26-2003
+ 05-27-2003
+ 05-28-2003
+ 05-29-2003
+ 05-30-2003
+ 05-31-2003
+ 06-01-2003
+ 06-02-2003
+ 06-03-2003
+ 06-04-2003
+ 06-05-2003
+ 06-06-2003
+ 06-07-2003
+ 06-08-2003
+ 06-09-2003
+ 06-10-2003
+ 06-11-2003
+ 06-12-2003
+ 06-13-2003
+ 06-14-2003
+ 06-15-2003
+ 06-16-2003
+ 06-17-2003
+ 06-18-2003
+ 06-19-2003
+ 06-20-2003
+ 06-21-2003
+ 06-22-2003
+ 06-23-2003
+ 06-24-2003
+ 06-25-2003
+ 06-26-2003
+ 06-27-2003
+ 06-28-2003
+ 06-29-2003
+ 06-30-2003
+ 07-01-2003
+ 07-02-2003
+ 07-03-2003
+ 07-04-2003
+ 07-05-2003
+ 07-06-2003
+ 07-07-2003
+ 07-08-2003
+ 07-09-2003
+ 07-10-2003
+ 07-11-2003
+ 07-12-2003
+ 07-13-2003
+ 07-14-2003
+ 07-15-2003
+ 07-16-2003
+ 07-17-2003
+ 07-18-2003
+ 07-19-2003
+ 07-20-2003
+ 07-21-2003
+ 07-22-2003
+ 07-23-2003
+ 07-24-2003
+ 07-25-2003
+ 07-26-2003
+ 07-27-2003
+ 07-28-2003
+ 07-29-2003
+ 07-30-2003
+ 07-31-2003
+ 08-01-2003
+ 08-02-2003
+ 08-03-2003
+ 08-04-2003
+ 08-05-2003
+ 08-06-2003
+ 08-07-2003
+ 08-08-2003
+ 08-09-2003
+ 08-10-2003
+ 08-11-2003
+ 08-12-2003
+ 08-13-2003
+ 08-14-2003
+ 08-15-2003
+ 08-16-2003
+ 08-17-2003
+ 08-18-2003
+ 08-19-2003
+ 08-20-2003
+ 08-21-2003
+ 08-22-2003
+ 08-23-2003
+ 08-24-2003
+ 08-25-2003
+ 08-26-2003
+ 08-27-2003
+ 08-28-2003
+ 08-29-2003
+ 08-30-2003
+ 08-31-2003
+ 09-01-2003
+ 09-02-2003
+ 09-03-2003
+ 09-04-2003
+ 09-05-2003
+ 09-06-2003
+ 09-07-2003
+ 09-08-2003
+ 09-09-2003
+ 09-10-2003
+ 09-11-2003
+ 09-12-2003
+ 09-13-2003
+ 09-14-2003
+ 09-15-2003
+ 09-16-2003
+ 09-17-2003
+ 09-18-2003
+ 09-19-2003
(2000 rows)
+select count(a) from test1 where a = '1998-04-25';
count
-------
1
(1 row)
+select count(a) from test1 where a > '1998-04-25';
count
-------
1972
(1 row)
+select count(a) from test1 where a < '1998-04-25';
count
-------
27
(1 row)
+select count(a) from test1 where a >= '1998-04-25';
count
-------
1973
(1 row)
+select count(a) from test1 where a <= '1998-04-25';
count
-------
28
(1 row)
+select count(a) from test1 where a <> '1998-04-25';
count
-------
1999
[8/9] incubator-hawq git commit: HAWQ-1612. Implement vectorized
aggregate functions, such as avg/sum/count.
Posted by rl...@apache.org.
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/ce2814d4/contrib/vexecutor/create_type.sql
----------------------------------------------------------------------
diff --git a/contrib/vexecutor/create_type.sql b/contrib/vexecutor/create_type.sql
deleted file mode 100644
index 87a2b63..0000000
--- a/contrib/vexecutor/create_type.sql
+++ /dev/null
@@ -1,960 +0,0 @@
--- drop types first
-drop type vint2 cascade;
-drop type vint4 cascade;
-drop type vint8 cascade;
-drop type vfloat8 cascade;
-drop type vfloat4 cascade;
-drop type vbool cascade;
-drop type vdateadt cascade;
-
--- create vectorized types
-
-CREATE TYPE vint2;
-CREATE FUNCTION vint2in(cstring) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE FUNCTION vint2out(vint2) RETURNS cstring AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE TYPE vint2 ( INPUT = vint2in, OUTPUT = vint2out, element = int2, storage=external );
-
-
-CREATE TYPE vint4;
-CREATE FUNCTION vint4in(cstring) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE FUNCTION vint4out(vint4) RETURNS cstring AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE TYPE vint4 ( INPUT = vint4in, OUTPUT = vint4out, element = int4, storage=external );
-
-CREATE TYPE vint8;
-CREATE FUNCTION vint8in(cstring) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE FUNCTION vint8out(vint8) RETURNS cstring AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE TYPE vint8 ( INPUT = vint8in, OUTPUT = vint8out, element = int8, storage=external );
-
-
-CREATE TYPE vfloat4;
-CREATE FUNCTION vfloat4in(cstring) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE FUNCTION vfloat4out(vfloat4) RETURNS cstring AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE TYPE vfloat4 ( INPUT = vfloat4in, OUTPUT = vfloat4out, element = float4, storage=external );
-
-
-CREATE TYPE vfloat8;
-CREATE FUNCTION vfloat8in(cstring) RETURNS vfloat8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE FUNCTION vfloat8out(vfloat8) RETURNS cstring AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE TYPE vfloat8 ( INPUT = vfloat8in, OUTPUT = vfloat8out, element = float8, storage=external );
-
-
-CREATE TYPE vbool;
-CREATE FUNCTION vboolin(cstring) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE FUNCTION vboolout(vbool) RETURNS cstring AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE TYPE vbool ( INPUT = vboolin, OUTPUT = vboolout, element = bool, storage=external );
-
-CREATE TYPE vdateadt;
-CREATE FUNCTION vdateadtin(cstring) RETURNS vdateadt as 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE FUNCTION vdateadtout(vdateadt) RETURNS cstring AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE TYPE vdateadt ( INPUT = vdateadtin, OUTPUT = vdateadtout, element = date , storage=external);
-
-
--- create operators for the vectorized types
-
-CREATE FUNCTION vint2vint2gt(vint2, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vint2, rightarg = vint2, procedure = vint2vint2gt, commutator = <= );
-CREATE FUNCTION vint2vint2ge(vint2, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vint2, rightarg = vint2, procedure = vint2vint2ge, commutator = < );
-CREATE FUNCTION vint2vint2eq(vint2, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vint2, rightarg = vint2, procedure = vint2vint2eq, commutator = <> );
-CREATE FUNCTION vint2vint2ne(vint2, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vint2, rightarg = vint2, procedure = vint2vint2ne, commutator = = );
-CREATE FUNCTION vint2vint2lt(vint2, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vint2, rightarg = vint2, procedure = vint2vint2lt, commutator = >= );
-CREATE FUNCTION vint2vint2le(vint2, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vint2, rightarg = vint2, procedure = vint2vint2le, commutator = > );
-CREATE FUNCTION vint2vint4gt(vint2, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vint2, rightarg = vint4, procedure = vint2vint4gt, commutator = <= );
-CREATE FUNCTION vint2vint4ge(vint2, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vint2, rightarg = vint4, procedure = vint2vint4ge, commutator = < );
-CREATE FUNCTION vint2vint4eq(vint2, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vint2, rightarg = vint4, procedure = vint2vint4eq, commutator = <> );
-CREATE FUNCTION vint2vint4ne(vint2, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vint2, rightarg = vint4, procedure = vint2vint4ne, commutator = = );
-CREATE FUNCTION vint2vint4lt(vint2, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vint2, rightarg = vint4, procedure = vint2vint4lt, commutator = >= );
-CREATE FUNCTION vint2vint4le(vint2, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vint2, rightarg = vint4, procedure = vint2vint4le, commutator = > );
-CREATE FUNCTION vint2vint8gt(vint2, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vint2, rightarg = vint8, procedure = vint2vint8gt, commutator = <= );
-CREATE FUNCTION vint2vint8ge(vint2, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vint2, rightarg = vint8, procedure = vint2vint8ge, commutator = < );
-CREATE FUNCTION vint2vint8eq(vint2, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vint2, rightarg = vint8, procedure = vint2vint8eq, commutator = <> );
-CREATE FUNCTION vint2vint8ne(vint2, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vint2, rightarg = vint8, procedure = vint2vint8ne, commutator = = );
-CREATE FUNCTION vint2vint8lt(vint2, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vint2, rightarg = vint8, procedure = vint2vint8lt, commutator = >= );
-CREATE FUNCTION vint2vint8le(vint2, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vint2, rightarg = vint8, procedure = vint2vint8le, commutator = > );
-CREATE FUNCTION vint2vfloat4gt(vint2, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vint2, rightarg = vfloat4, procedure = vint2vfloat4gt, commutator = <= );
-CREATE FUNCTION vint2vfloat4ge(vint2, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vint2, rightarg = vfloat4, procedure = vint2vfloat4ge, commutator = < );
-CREATE FUNCTION vint2vfloat4eq(vint2, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vint2, rightarg = vfloat4, procedure = vint2vfloat4eq, commutator = <> );
-CREATE FUNCTION vint2vfloat4ne(vint2, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vint2, rightarg = vfloat4, procedure = vint2vfloat4ne, commutator = = );
-CREATE FUNCTION vint2vfloat4lt(vint2, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vint2, rightarg = vfloat4, procedure = vint2vfloat4lt, commutator = >= );
-CREATE FUNCTION vint2vfloat4le(vint2, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vint2, rightarg = vfloat4, procedure = vint2vfloat4le, commutator = > );
-CREATE FUNCTION vint2vfloat8gt(vint2, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vint2, rightarg = vfloat8, procedure = vint2vfloat8gt, commutator = <= );
-CREATE FUNCTION vint2vfloat8ge(vint2, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vint2, rightarg = vfloat8, procedure = vint2vfloat8ge, commutator = < );
-CREATE FUNCTION vint2vfloat8eq(vint2, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vint2, rightarg = vfloat8, procedure = vint2vfloat8eq, commutator = <> );
-CREATE FUNCTION vint2vfloat8ne(vint2, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vint2, rightarg = vfloat8, procedure = vint2vfloat8ne, commutator = = );
-CREATE FUNCTION vint2vfloat8lt(vint2, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vint2, rightarg = vfloat8, procedure = vint2vfloat8lt, commutator = >= );
-CREATE FUNCTION vint2vfloat8le(vint2, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vint2, rightarg = vfloat8, procedure = vint2vfloat8le, commutator = > );
-CREATE FUNCTION vint2int2gt(vint2, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vint2, rightarg = int2, procedure = vint2int2gt, commutator = <= );
-CREATE FUNCTION vint2int2ge(vint2, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vint2, rightarg = int2, procedure = vint2int2ge, commutator = < );
-CREATE FUNCTION vint2int2eq(vint2, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vint2, rightarg = int2, procedure = vint2int2eq, commutator = <> );
-CREATE FUNCTION vint2int2ne(vint2, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vint2, rightarg = int2, procedure = vint2int2ne, commutator = = );
-CREATE FUNCTION vint2int2lt(vint2, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vint2, rightarg = int2, procedure = vint2int2lt, commutator = >= );
-CREATE FUNCTION vint2int2le(vint2, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vint2, rightarg = int2, procedure = vint2int2le, commutator = > );
-CREATE FUNCTION vint2int4gt(vint2, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vint2, rightarg = int4, procedure = vint2int4gt, commutator = <= );
-CREATE FUNCTION vint2int4ge(vint2, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vint2, rightarg = int4, procedure = vint2int4ge, commutator = < );
-CREATE FUNCTION vint2int4eq(vint2, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vint2, rightarg = int4, procedure = vint2int4eq, commutator = <> );
-CREATE FUNCTION vint2int4ne(vint2, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vint2, rightarg = int4, procedure = vint2int4ne, commutator = = );
-CREATE FUNCTION vint2int4lt(vint2, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vint2, rightarg = int4, procedure = vint2int4lt, commutator = >= );
-CREATE FUNCTION vint2int4le(vint2, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vint2, rightarg = int4, procedure = vint2int4le, commutator = > );
-CREATE FUNCTION vint2int8gt(vint2, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vint2, rightarg = int8, procedure = vint2int8gt, commutator = <= );
-CREATE FUNCTION vint2int8ge(vint2, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vint2, rightarg = int8, procedure = vint2int8ge, commutator = < );
-CREATE FUNCTION vint2int8eq(vint2, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vint2, rightarg = int8, procedure = vint2int8eq, commutator = <> );
-CREATE FUNCTION vint2int8ne(vint2, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vint2, rightarg = int8, procedure = vint2int8ne, commutator = = );
-CREATE FUNCTION vint2int8lt(vint2, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vint2, rightarg = int8, procedure = vint2int8lt, commutator = >= );
-CREATE FUNCTION vint2int8le(vint2, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vint2, rightarg = int8, procedure = vint2int8le, commutator = > );
-CREATE FUNCTION vint2float4gt(vint2, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vint2, rightarg = float4, procedure = vint2float4gt, commutator = <= );
-CREATE FUNCTION vint2float4ge(vint2, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vint2, rightarg = float4, procedure = vint2float4ge, commutator = < );
-CREATE FUNCTION vint2float4eq(vint2, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vint2, rightarg = float4, procedure = vint2float4eq, commutator = <> );
-CREATE FUNCTION vint2float4ne(vint2, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vint2, rightarg = float4, procedure = vint2float4ne, commutator = = );
-CREATE FUNCTION vint2float4lt(vint2, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vint2, rightarg = float4, procedure = vint2float4lt, commutator = >= );
-CREATE FUNCTION vint2float4le(vint2, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vint2, rightarg = float4, procedure = vint2float4le, commutator = > );
-CREATE FUNCTION vint2float8gt(vint2, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vint2, rightarg = float8, procedure = vint2float8gt, commutator = <= );
-CREATE FUNCTION vint2float8ge(vint2, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vint2, rightarg = float8, procedure = vint2float8ge, commutator = < );
-CREATE FUNCTION vint2float8eq(vint2, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vint2, rightarg = float8, procedure = vint2float8eq, commutator = <> );
-CREATE FUNCTION vint2float8ne(vint2, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vint2, rightarg = float8, procedure = vint2float8ne, commutator = = );
-CREATE FUNCTION vint2float8lt(vint2, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vint2, rightarg = float8, procedure = vint2float8lt, commutator = >= );
-CREATE FUNCTION vint2float8le(vint2, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vint2, rightarg = float8, procedure = vint2float8le, commutator = > );
-
-CREATE FUNCTION vint4vint2gt(vint4, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vint4, rightarg = vint2, procedure = vint4vint2gt, commutator = <= );
-CREATE FUNCTION vint4vint2ge(vint4, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vint4, rightarg = vint2, procedure = vint4vint2ge, commutator = < );
-CREATE FUNCTION vint4vint2eq(vint4, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vint4, rightarg = vint2, procedure = vint4vint2eq, commutator = <> );
-CREATE FUNCTION vint4vint2ne(vint4, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vint4, rightarg = vint2, procedure = vint4vint2ne, commutator = = );
-CREATE FUNCTION vint4vint2lt(vint4, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vint4, rightarg = vint2, procedure = vint4vint2lt, commutator = >= );
-CREATE FUNCTION vint4vint2le(vint4, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vint4, rightarg = vint2, procedure = vint4vint2le, commutator = > );
-CREATE FUNCTION vint4vint4gt(vint4, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vint4, rightarg = vint4, procedure = vint4vint4gt, commutator = <= );
-CREATE FUNCTION vint4vint4ge(vint4, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vint4, rightarg = vint4, procedure = vint4vint4ge, commutator = < );
-CREATE FUNCTION vint4vint4eq(vint4, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vint4, rightarg = vint4, procedure = vint4vint4eq, commutator = <> );
-CREATE FUNCTION vint4vint4ne(vint4, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vint4, rightarg = vint4, procedure = vint4vint4ne, commutator = = );
-CREATE FUNCTION vint4vint4lt(vint4, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vint4, rightarg = vint4, procedure = vint4vint4lt, commutator = >= );
-CREATE FUNCTION vint4vint4le(vint4, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vint4, rightarg = vint4, procedure = vint4vint4le, commutator = > );
-CREATE FUNCTION vint4vint8gt(vint4, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vint4, rightarg = vint8, procedure = vint4vint8gt, commutator = <= );
-CREATE FUNCTION vint4vint8ge(vint4, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vint4, rightarg = vint8, procedure = vint4vint8ge, commutator = < );
-CREATE FUNCTION vint4vint8eq(vint4, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vint4, rightarg = vint8, procedure = vint4vint8eq, commutator = <> );
-CREATE FUNCTION vint4vint8ne(vint4, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vint4, rightarg = vint8, procedure = vint4vint8ne, commutator = = );
-CREATE FUNCTION vint4vint8lt(vint4, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vint4, rightarg = vint8, procedure = vint4vint8lt, commutator = >= );
-CREATE FUNCTION vint4vint8le(vint4, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vint4, rightarg = vint8, procedure = vint4vint8le, commutator = > );
-CREATE FUNCTION vint4vfloat4gt(vint4, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vint4, rightarg = vfloat4, procedure = vint4vfloat4gt, commutator = <= );
-CREATE FUNCTION vint4vfloat4ge(vint4, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vint4, rightarg = vfloat4, procedure = vint4vfloat4ge, commutator = < );
-CREATE FUNCTION vint4vfloat4eq(vint4, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vint4, rightarg = vfloat4, procedure = vint4vfloat4eq, commutator = <> );
-CREATE FUNCTION vint4vfloat4ne(vint4, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vint4, rightarg = vfloat4, procedure = vint4vfloat4ne, commutator = = );
-CREATE FUNCTION vint4vfloat4lt(vint4, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vint4, rightarg = vfloat4, procedure = vint4vfloat4lt, commutator = >= );
-CREATE FUNCTION vint4vfloat4le(vint4, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vint4, rightarg = vfloat4, procedure = vint4vfloat4le, commutator = > );
-CREATE FUNCTION vint4vfloat8gt(vint4, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vint4, rightarg = vfloat8, procedure = vint4vfloat8gt, commutator = <= );
-CREATE FUNCTION vint4vfloat8ge(vint4, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vint4, rightarg = vfloat8, procedure = vint4vfloat8ge, commutator = < );
-CREATE FUNCTION vint4vfloat8eq(vint4, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vint4, rightarg = vfloat8, procedure = vint4vfloat8eq, commutator = <> );
-CREATE FUNCTION vint4vfloat8ne(vint4, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vint4, rightarg = vfloat8, procedure = vint4vfloat8ne, commutator = = );
-CREATE FUNCTION vint4vfloat8lt(vint4, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vint4, rightarg = vfloat8, procedure = vint4vfloat8lt, commutator = >= );
-CREATE FUNCTION vint4vfloat8le(vint4, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vint4, rightarg = vfloat8, procedure = vint4vfloat8le, commutator = > );
-CREATE FUNCTION vint4int2gt(vint4, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vint4, rightarg = int2, procedure = vint4int2gt, commutator = <= );
-CREATE FUNCTION vint4int2ge(vint4, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vint4, rightarg = int2, procedure = vint4int2ge, commutator = < );
-CREATE FUNCTION vint4int2eq(vint4, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vint4, rightarg = int2, procedure = vint4int2eq, commutator = <> );
-CREATE FUNCTION vint4int2ne(vint4, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vint4, rightarg = int2, procedure = vint4int2ne, commutator = = );
-CREATE FUNCTION vint4int2lt(vint4, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vint4, rightarg = int2, procedure = vint4int2lt, commutator = >= );
-CREATE FUNCTION vint4int2le(vint4, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vint4, rightarg = int2, procedure = vint4int2le, commutator = > );
-CREATE FUNCTION vint4int4gt(vint4, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vint4, rightarg = int4, procedure = vint4int4gt, commutator = <= );
-CREATE FUNCTION vint4int4ge(vint4, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vint4, rightarg = int4, procedure = vint4int4ge, commutator = < );
-CREATE FUNCTION vint4int4eq(vint4, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vint4, rightarg = int4, procedure = vint4int4eq, commutator = <> );
-CREATE FUNCTION vint4int4ne(vint4, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vint4, rightarg = int4, procedure = vint4int4ne, commutator = = );
-CREATE FUNCTION vint4int4lt(vint4, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vint4, rightarg = int4, procedure = vint4int4lt, commutator = >= );
-CREATE FUNCTION vint4int4le(vint4, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vint4, rightarg = int4, procedure = vint4int4le, commutator = > );
-CREATE FUNCTION vint4int8gt(vint4, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vint4, rightarg = int8, procedure = vint4int8gt, commutator = <= );
-CREATE FUNCTION vint4int8ge(vint4, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vint4, rightarg = int8, procedure = vint4int8ge, commutator = < );
-CREATE FUNCTION vint4int8eq(vint4, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vint4, rightarg = int8, procedure = vint4int8eq, commutator = <> );
-CREATE FUNCTION vint4int8ne(vint4, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vint4, rightarg = int8, procedure = vint4int8ne, commutator = = );
-CREATE FUNCTION vint4int8lt(vint4, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vint4, rightarg = int8, procedure = vint4int8lt, commutator = >= );
-CREATE FUNCTION vint4int8le(vint4, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vint4, rightarg = int8, procedure = vint4int8le, commutator = > );
-CREATE FUNCTION vint4float4gt(vint4, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vint4, rightarg = float4, procedure = vint4float4gt, commutator = <= );
-CREATE FUNCTION vint4float4ge(vint4, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vint4, rightarg = float4, procedure = vint4float4ge, commutator = < );
-CREATE FUNCTION vint4float4eq(vint4, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vint4, rightarg = float4, procedure = vint4float4eq, commutator = <> );
-CREATE FUNCTION vint4float4ne(vint4, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vint4, rightarg = float4, procedure = vint4float4ne, commutator = = );
-CREATE FUNCTION vint4float4lt(vint4, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vint4, rightarg = float4, procedure = vint4float4lt, commutator = >= );
-CREATE FUNCTION vint4float4le(vint4, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vint4, rightarg = float4, procedure = vint4float4le, commutator = > );
-CREATE FUNCTION vint4float8gt(vint4, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vint4, rightarg = float8, procedure = vint4float8gt, commutator = <= );
-CREATE FUNCTION vint4float8ge(vint4, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vint4, rightarg = float8, procedure = vint4float8ge, commutator = < );
-CREATE FUNCTION vint4float8eq(vint4, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vint4, rightarg = float8, procedure = vint4float8eq, commutator = <> );
-CREATE FUNCTION vint4float8ne(vint4, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vint4, rightarg = float8, procedure = vint4float8ne, commutator = = );
-CREATE FUNCTION vint4float8lt(vint4, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vint4, rightarg = float8, procedure = vint4float8lt, commutator = >= );
-CREATE FUNCTION vint4float8le(vint4, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vint4, rightarg = float8, procedure = vint4float8le, commutator = > );
-
-CREATE FUNCTION vint8vint2gt(vint8, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vint8, rightarg = vint2, procedure = vint8vint2gt, commutator = <= );
-CREATE FUNCTION vint8vint2ge(vint8, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vint8, rightarg = vint2, procedure = vint8vint2ge, commutator = < );
-CREATE FUNCTION vint8vint2eq(vint8, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vint8, rightarg = vint2, procedure = vint8vint2eq, commutator = <> );
-CREATE FUNCTION vint8vint2ne(vint8, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vint8, rightarg = vint2, procedure = vint8vint2ne, commutator = = );
-CREATE FUNCTION vint8vint2lt(vint8, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vint8, rightarg = vint2, procedure = vint8vint2lt, commutator = >= );
-CREATE FUNCTION vint8vint2le(vint8, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vint8, rightarg = vint2, procedure = vint8vint2le, commutator = > );
-CREATE FUNCTION vint8vint4gt(vint8, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vint8, rightarg = vint4, procedure = vint8vint4gt, commutator = <= );
-CREATE FUNCTION vint8vint4ge(vint8, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vint8, rightarg = vint4, procedure = vint8vint4ge, commutator = < );
-CREATE FUNCTION vint8vint4eq(vint8, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vint8, rightarg = vint4, procedure = vint8vint4eq, commutator = <> );
-CREATE FUNCTION vint8vint4ne(vint8, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vint8, rightarg = vint4, procedure = vint8vint4ne, commutator = = );
-CREATE FUNCTION vint8vint4lt(vint8, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vint8, rightarg = vint4, procedure = vint8vint4lt, commutator = >= );
-CREATE FUNCTION vint8vint4le(vint8, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vint8, rightarg = vint4, procedure = vint8vint4le, commutator = > );
-CREATE FUNCTION vint8vint8gt(vint8, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vint8, rightarg = vint8, procedure = vint8vint8gt, commutator = <= );
-CREATE FUNCTION vint8vint8ge(vint8, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vint8, rightarg = vint8, procedure = vint8vint8ge, commutator = < );
-CREATE FUNCTION vint8vint8eq(vint8, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vint8, rightarg = vint8, procedure = vint8vint8eq, commutator = <> );
-CREATE FUNCTION vint8vint8ne(vint8, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vint8, rightarg = vint8, procedure = vint8vint8ne, commutator = = );
-CREATE FUNCTION vint8vint8lt(vint8, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vint8, rightarg = vint8, procedure = vint8vint8lt, commutator = >= );
-CREATE FUNCTION vint8vint8le(vint8, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vint8, rightarg = vint8, procedure = vint8vint8le, commutator = > );
-CREATE FUNCTION vint8vfloat4gt(vint8, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vint8, rightarg = vfloat4, procedure = vint8vfloat4gt, commutator = <= );
-CREATE FUNCTION vint8vfloat4ge(vint8, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vint8, rightarg = vfloat4, procedure = vint8vfloat4ge, commutator = < );
-CREATE FUNCTION vint8vfloat4eq(vint8, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vint8, rightarg = vfloat4, procedure = vint8vfloat4eq, commutator = <> );
-CREATE FUNCTION vint8vfloat4ne(vint8, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vint8, rightarg = vfloat4, procedure = vint8vfloat4ne, commutator = = );
-CREATE FUNCTION vint8vfloat4lt(vint8, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vint8, rightarg = vfloat4, procedure = vint8vfloat4lt, commutator = >= );
-CREATE FUNCTION vint8vfloat4le(vint8, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vint8, rightarg = vfloat4, procedure = vint8vfloat4le, commutator = > );
-CREATE FUNCTION vint8vfloat8gt(vint8, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vint8, rightarg = vfloat8, procedure = vint8vfloat8gt, commutator = <= );
-CREATE FUNCTION vint8vfloat8ge(vint8, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vint8, rightarg = vfloat8, procedure = vint8vfloat8ge, commutator = < );
-CREATE FUNCTION vint8vfloat8eq(vint8, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vint8, rightarg = vfloat8, procedure = vint8vfloat8eq, commutator = <> );
-CREATE FUNCTION vint8vfloat8ne(vint8, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vint8, rightarg = vfloat8, procedure = vint8vfloat8ne, commutator = = );
-CREATE FUNCTION vint8vfloat8lt(vint8, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vint8, rightarg = vfloat8, procedure = vint8vfloat8lt, commutator = >= );
-CREATE FUNCTION vint8vfloat8le(vint8, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vint8, rightarg = vfloat8, procedure = vint8vfloat8le, commutator = > );
-CREATE FUNCTION vint8int2gt(vint8, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vint8, rightarg = int2, procedure = vint8int2gt, commutator = <= );
-CREATE FUNCTION vint8int2ge(vint8, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vint8, rightarg = int2, procedure = vint8int2ge, commutator = < );
-CREATE FUNCTION vint8int2eq(vint8, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vint8, rightarg = int2, procedure = vint8int2eq, commutator = <> );
-CREATE FUNCTION vint8int2ne(vint8, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vint8, rightarg = int2, procedure = vint8int2ne, commutator = = );
-CREATE FUNCTION vint8int2lt(vint8, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vint8, rightarg = int2, procedure = vint8int2lt, commutator = >= );
-CREATE FUNCTION vint8int2le(vint8, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vint8, rightarg = int2, procedure = vint8int2le, commutator = > );
-CREATE FUNCTION vint8int4gt(vint8, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vint8, rightarg = int4, procedure = vint8int4gt, commutator = <= );
-CREATE FUNCTION vint8int4ge(vint8, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vint8, rightarg = int4, procedure = vint8int4ge, commutator = < );
-CREATE FUNCTION vint8int4eq(vint8, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vint8, rightarg = int4, procedure = vint8int4eq, commutator = <> );
-CREATE FUNCTION vint8int4ne(vint8, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vint8, rightarg = int4, procedure = vint8int4ne, commutator = = );
-CREATE FUNCTION vint8int4lt(vint8, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vint8, rightarg = int4, procedure = vint8int4lt, commutator = >= );
-CREATE FUNCTION vint8int4le(vint8, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vint8, rightarg = int4, procedure = vint8int4le, commutator = > );
-CREATE FUNCTION vint8int8gt(vint8, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vint8, rightarg = int8, procedure = vint8int8gt, commutator = <= );
-CREATE FUNCTION vint8int8ge(vint8, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vint8, rightarg = int8, procedure = vint8int8ge, commutator = < );
-CREATE FUNCTION vint8int8eq(vint8, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vint8, rightarg = int8, procedure = vint8int8eq, commutator = <> );
-CREATE FUNCTION vint8int8ne(vint8, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vint8, rightarg = int8, procedure = vint8int8ne, commutator = = );
-CREATE FUNCTION vint8int8lt(vint8, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vint8, rightarg = int8, procedure = vint8int8lt, commutator = >= );
-CREATE FUNCTION vint8int8le(vint8, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vint8, rightarg = int8, procedure = vint8int8le, commutator = > );
-CREATE FUNCTION vint8float4gt(vint8, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vint8, rightarg = float4, procedure = vint8float4gt, commutator = <= );
-CREATE FUNCTION vint8float4ge(vint8, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vint8, rightarg = float4, procedure = vint8float4ge, commutator = < );
-CREATE FUNCTION vint8float4eq(vint8, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vint8, rightarg = float4, procedure = vint8float4eq, commutator = <> );
-CREATE FUNCTION vint8float4ne(vint8, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vint8, rightarg = float4, procedure = vint8float4ne, commutator = = );
-CREATE FUNCTION vint8float4lt(vint8, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vint8, rightarg = float4, procedure = vint8float4lt, commutator = >= );
-CREATE FUNCTION vint8float4le(vint8, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vint8, rightarg = float4, procedure = vint8float4le, commutator = > );
-CREATE FUNCTION vint8float8gt(vint8, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vint8, rightarg = float8, procedure = vint8float8gt, commutator = <= );
-CREATE FUNCTION vint8float8ge(vint8, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vint8, rightarg = float8, procedure = vint8float8ge, commutator = < );
-CREATE FUNCTION vint8float8eq(vint8, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vint8, rightarg = float8, procedure = vint8float8eq, commutator = <> );
-CREATE FUNCTION vint8float8ne(vint8, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vint8, rightarg = float8, procedure = vint8float8ne, commutator = = );
-CREATE FUNCTION vint8float8lt(vint8, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vint8, rightarg = float8, procedure = vint8float8lt, commutator = >= );
-CREATE FUNCTION vint8float8le(vint8, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vint8, rightarg = float8, procedure = vint8float8le, commutator = > );
-
-CREATE FUNCTION vfloat4vint2gt(vfloat4, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vfloat4, rightarg = vint2, procedure = vfloat4vint2gt, commutator = <= );
-CREATE FUNCTION vfloat4vint2ge(vfloat4, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vfloat4, rightarg = vint2, procedure = vfloat4vint2ge, commutator = < );
-CREATE FUNCTION vfloat4vint2eq(vfloat4, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vfloat4, rightarg = vint2, procedure = vfloat4vint2eq, commutator = <> );
-CREATE FUNCTION vfloat4vint2ne(vfloat4, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vfloat4, rightarg = vint2, procedure = vfloat4vint2ne, commutator = = );
-CREATE FUNCTION vfloat4vint2lt(vfloat4, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vfloat4, rightarg = vint2, procedure = vfloat4vint2lt, commutator = >= );
-CREATE FUNCTION vfloat4vint2le(vfloat4, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vfloat4, rightarg = vint2, procedure = vfloat4vint2le, commutator = > );
-CREATE FUNCTION vfloat4vint4gt(vfloat4, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vfloat4, rightarg = vint4, procedure = vfloat4vint4gt, commutator = <= );
-CREATE FUNCTION vfloat4vint4ge(vfloat4, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vfloat4, rightarg = vint4, procedure = vfloat4vint4ge, commutator = < );
-CREATE FUNCTION vfloat4vint4eq(vfloat4, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vfloat4, rightarg = vint4, procedure = vfloat4vint4eq, commutator = <> );
-CREATE FUNCTION vfloat4vint4ne(vfloat4, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vfloat4, rightarg = vint4, procedure = vfloat4vint4ne, commutator = = );
-CREATE FUNCTION vfloat4vint4lt(vfloat4, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vfloat4, rightarg = vint4, procedure = vfloat4vint4lt, commutator = >= );
-CREATE FUNCTION vfloat4vint4le(vfloat4, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vfloat4, rightarg = vint4, procedure = vfloat4vint4le, commutator = > );
-CREATE FUNCTION vfloat4vint8gt(vfloat4, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vfloat4, rightarg = vint8, procedure = vfloat4vint8gt, commutator = <= );
-CREATE FUNCTION vfloat4vint8ge(vfloat4, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vfloat4, rightarg = vint8, procedure = vfloat4vint8ge, commutator = < );
-CREATE FUNCTION vfloat4vint8eq(vfloat4, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vfloat4, rightarg = vint8, procedure = vfloat4vint8eq, commutator = <> );
-CREATE FUNCTION vfloat4vint8ne(vfloat4, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vfloat4, rightarg = vint8, procedure = vfloat4vint8ne, commutator = = );
-CREATE FUNCTION vfloat4vint8lt(vfloat4, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vfloat4, rightarg = vint8, procedure = vfloat4vint8lt, commutator = >= );
-CREATE FUNCTION vfloat4vint8le(vfloat4, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vfloat4, rightarg = vint8, procedure = vfloat4vint8le, commutator = > );
-CREATE FUNCTION vfloat4vfloat4gt(vfloat4, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vfloat4, rightarg = vfloat4, procedure = vfloat4vfloat4gt, commutator = <= );
-CREATE FUNCTION vfloat4vfloat4ge(vfloat4, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vfloat4, rightarg = vfloat4, procedure = vfloat4vfloat4ge, commutator = < );
-CREATE FUNCTION vfloat4vfloat4eq(vfloat4, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vfloat4, rightarg = vfloat4, procedure = vfloat4vfloat4eq, commutator = <> );
-CREATE FUNCTION vfloat4vfloat4ne(vfloat4, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vfloat4, rightarg = vfloat4, procedure = vfloat4vfloat4ne, commutator = = );
-CREATE FUNCTION vfloat4vfloat4lt(vfloat4, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vfloat4, rightarg = vfloat4, procedure = vfloat4vfloat4lt, commutator = >= );
-CREATE FUNCTION vfloat4vfloat4le(vfloat4, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vfloat4, rightarg = vfloat4, procedure = vfloat4vfloat4le, commutator = > );
-CREATE FUNCTION vfloat4vfloat8gt(vfloat4, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vfloat4, rightarg = vfloat8, procedure = vfloat4vfloat8gt, commutator = <= );
-CREATE FUNCTION vfloat4vfloat8ge(vfloat4, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vfloat4, rightarg = vfloat8, procedure = vfloat4vfloat8ge, commutator = < );
-CREATE FUNCTION vfloat4vfloat8eq(vfloat4, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vfloat4, rightarg = vfloat8, procedure = vfloat4vfloat8eq, commutator = <> );
-CREATE FUNCTION vfloat4vfloat8ne(vfloat4, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vfloat4, rightarg = vfloat8, procedure = vfloat4vfloat8ne, commutator = = );
-CREATE FUNCTION vfloat4vfloat8lt(vfloat4, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vfloat4, rightarg = vfloat8, procedure = vfloat4vfloat8lt, commutator = >= );
-CREATE FUNCTION vfloat4vfloat8le(vfloat4, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vfloat4, rightarg = vfloat8, procedure = vfloat4vfloat8le, commutator = > );
-CREATE FUNCTION vfloat4int2gt(vfloat4, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vfloat4, rightarg = int2, procedure = vfloat4int2gt, commutator = <= );
-CREATE FUNCTION vfloat4int2ge(vfloat4, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vfloat4, rightarg = int2, procedure = vfloat4int2ge, commutator = < );
-CREATE FUNCTION vfloat4int2eq(vfloat4, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vfloat4, rightarg = int2, procedure = vfloat4int2eq, commutator = <> );
-CREATE FUNCTION vfloat4int2ne(vfloat4, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vfloat4, rightarg = int2, procedure = vfloat4int2ne, commutator = = );
-CREATE FUNCTION vfloat4int2lt(vfloat4, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vfloat4, rightarg = int2, procedure = vfloat4int2lt, commutator = >= );
-CREATE FUNCTION vfloat4int2le(vfloat4, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vfloat4, rightarg = int2, procedure = vfloat4int2le, commutator = > );
-CREATE FUNCTION vfloat4int4gt(vfloat4, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vfloat4, rightarg = int4, procedure = vfloat4int4gt, commutator = <= );
-CREATE FUNCTION vfloat4int4ge(vfloat4, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vfloat4, rightarg = int4, procedure = vfloat4int4ge, commutator = < );
-CREATE FUNCTION vfloat4int4eq(vfloat4, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vfloat4, rightarg = int4, procedure = vfloat4int4eq, commutator = <> );
-CREATE FUNCTION vfloat4int4ne(vfloat4, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vfloat4, rightarg = int4, procedure = vfloat4int4ne, commutator = = );
-CREATE FUNCTION vfloat4int4lt(vfloat4, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vfloat4, rightarg = int4, procedure = vfloat4int4lt, commutator = >= );
-CREATE FUNCTION vfloat4int4le(vfloat4, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vfloat4, rightarg = int4, procedure = vfloat4int4le, commutator = > );
-CREATE FUNCTION vfloat4int8gt(vfloat4, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vfloat4, rightarg = int8, procedure = vfloat4int8gt, commutator = <= );
-CREATE FUNCTION vfloat4int8ge(vfloat4, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vfloat4, rightarg = int8, procedure = vfloat4int8ge, commutator = < );
-CREATE FUNCTION vfloat4int8eq(vfloat4, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vfloat4, rightarg = int8, procedure = vfloat4int8eq, commutator = <> );
-CREATE FUNCTION vfloat4int8ne(vfloat4, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vfloat4, rightarg = int8, procedure = vfloat4int8ne, commutator = = );
-CREATE FUNCTION vfloat4int8lt(vfloat4, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vfloat4, rightarg = int8, procedure = vfloat4int8lt, commutator = >= );
-CREATE FUNCTION vfloat4int8le(vfloat4, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vfloat4, rightarg = int8, procedure = vfloat4int8le, commutator = > );
-CREATE FUNCTION vfloat4float4gt(vfloat4, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vfloat4, rightarg = float4, procedure = vfloat4float4gt, commutator = <= );
-CREATE FUNCTION vfloat4float4ge(vfloat4, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vfloat4, rightarg = float4, procedure = vfloat4float4ge, commutator = < );
-CREATE FUNCTION vfloat4float4eq(vfloat4, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vfloat4, rightarg = float4, procedure = vfloat4float4eq, commutator = <> );
-CREATE FUNCTION vfloat4float4ne(vfloat4, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vfloat4, rightarg = float4, procedure = vfloat4float4ne, commutator = = );
-CREATE FUNCTION vfloat4float4lt(vfloat4, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vfloat4, rightarg = float4, procedure = vfloat4float4lt, commutator = >= );
-CREATE FUNCTION vfloat4float4le(vfloat4, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vfloat4, rightarg = float4, procedure = vfloat4float4le, commutator = > );
-CREATE FUNCTION vfloat4float8gt(vfloat4, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vfloat4, rightarg = float8, procedure = vfloat4float8gt, commutator = <= );
-CREATE FUNCTION vfloat4float8ge(vfloat4, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vfloat4, rightarg = float8, procedure = vfloat4float8ge, commutator = < );
-CREATE FUNCTION vfloat4float8eq(vfloat4, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vfloat4, rightarg = float8, procedure = vfloat4float8eq, commutator = <> );
-CREATE FUNCTION vfloat4float8ne(vfloat4, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vfloat4, rightarg = float8, procedure = vfloat4float8ne, commutator = = );
-CREATE FUNCTION vfloat4float8lt(vfloat4, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vfloat4, rightarg = float8, procedure = vfloat4float8lt, commutator = >= );
-CREATE FUNCTION vfloat4float8le(vfloat4, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vfloat4, rightarg = float8, procedure = vfloat4float8le, commutator = > );
-
-CREATE FUNCTION vfloat8vint2gt(vfloat8, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vfloat8, rightarg = vint2, procedure = vfloat8vint2gt, commutator = <= );
-CREATE FUNCTION vfloat8vint2ge(vfloat8, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vfloat8, rightarg = vint2, procedure = vfloat8vint2ge, commutator = < );
-CREATE FUNCTION vfloat8vint2eq(vfloat8, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vfloat8, rightarg = vint2, procedure = vfloat8vint2eq, commutator = <> );
-CREATE FUNCTION vfloat8vint2ne(vfloat8, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vfloat8, rightarg = vint2, procedure = vfloat8vint2ne, commutator = = );
-CREATE FUNCTION vfloat8vint2lt(vfloat8, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vfloat8, rightarg = vint2, procedure = vfloat8vint2lt, commutator = >= );
-CREATE FUNCTION vfloat8vint2le(vfloat8, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vfloat8, rightarg = vint2, procedure = vfloat8vint2le, commutator = > );
-CREATE FUNCTION vfloat8vint4gt(vfloat8, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vfloat8, rightarg = vint4, procedure = vfloat8vint4gt, commutator = <= );
-CREATE FUNCTION vfloat8vint4ge(vfloat8, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vfloat8, rightarg = vint4, procedure = vfloat8vint4ge, commutator = < );
-CREATE FUNCTION vfloat8vint4eq(vfloat8, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vfloat8, rightarg = vint4, procedure = vfloat8vint4eq, commutator = <> );
-CREATE FUNCTION vfloat8vint4ne(vfloat8, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vfloat8, rightarg = vint4, procedure = vfloat8vint4ne, commutator = = );
-CREATE FUNCTION vfloat8vint4lt(vfloat8, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vfloat8, rightarg = vint4, procedure = vfloat8vint4lt, commutator = >= );
-CREATE FUNCTION vfloat8vint4le(vfloat8, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vfloat8, rightarg = vint4, procedure = vfloat8vint4le, commutator = > );
-CREATE FUNCTION vfloat8vint8gt(vfloat8, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vfloat8, rightarg = vint8, procedure = vfloat8vint8gt, commutator = <= );
-CREATE FUNCTION vfloat8vint8ge(vfloat8, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vfloat8, rightarg = vint8, procedure = vfloat8vint8ge, commutator = < );
-CREATE FUNCTION vfloat8vint8eq(vfloat8, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vfloat8, rightarg = vint8, procedure = vfloat8vint8eq, commutator = <> );
-CREATE FUNCTION vfloat8vint8ne(vfloat8, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vfloat8, rightarg = vint8, procedure = vfloat8vint8ne, commutator = = );
-CREATE FUNCTION vfloat8vint8lt(vfloat8, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vfloat8, rightarg = vint8, procedure = vfloat8vint8lt, commutator = >= );
-CREATE FUNCTION vfloat8vint8le(vfloat8, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vfloat8, rightarg = vint8, procedure = vfloat8vint8le, commutator = > );
-CREATE FUNCTION vfloat8vfloat4gt(vfloat8, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vfloat8, rightarg = vfloat4, procedure = vfloat8vfloat4gt, commutator = <= );
-CREATE FUNCTION vfloat8vfloat4ge(vfloat8, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vfloat8, rightarg = vfloat4, procedure = vfloat8vfloat4ge, commutator = < );
-CREATE FUNCTION vfloat8vfloat4eq(vfloat8, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vfloat8, rightarg = vfloat4, procedure = vfloat8vfloat4eq, commutator = <> );
-CREATE FUNCTION vfloat8vfloat4ne(vfloat8, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vfloat8, rightarg = vfloat4, procedure = vfloat8vfloat4ne, commutator = = );
-CREATE FUNCTION vfloat8vfloat4lt(vfloat8, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vfloat8, rightarg = vfloat4, procedure = vfloat8vfloat4lt, commutator = >= );
-CREATE FUNCTION vfloat8vfloat4le(vfloat8, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vfloat8, rightarg = vfloat4, procedure = vfloat8vfloat4le, commutator = > );
-CREATE FUNCTION vfloat8vfloat8gt(vfloat8, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vfloat8, rightarg = vfloat8, procedure = vfloat8vfloat8gt, commutator = <= );
-CREATE FUNCTION vfloat8vfloat8ge(vfloat8, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vfloat8, rightarg = vfloat8, procedure = vfloat8vfloat8ge, commutator = < );
-CREATE FUNCTION vfloat8vfloat8eq(vfloat8, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vfloat8, rightarg = vfloat8, procedure = vfloat8vfloat8eq, commutator = <> );
-CREATE FUNCTION vfloat8vfloat8ne(vfloat8, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vfloat8, rightarg = vfloat8, procedure = vfloat8vfloat8ne, commutator = = );
-CREATE FUNCTION vfloat8vfloat8lt(vfloat8, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vfloat8, rightarg = vfloat8, procedure = vfloat8vfloat8lt, commutator = >= );
-CREATE FUNCTION vfloat8vfloat8le(vfloat8, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vfloat8, rightarg = vfloat8, procedure = vfloat8vfloat8le, commutator = > );
-CREATE FUNCTION vfloat8int2gt(vfloat8, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vfloat8, rightarg = int2, procedure = vfloat8int2gt, commutator = <= );
-CREATE FUNCTION vfloat8int2ge(vfloat8, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vfloat8, rightarg = int2, procedure = vfloat8int2ge, commutator = < );
-CREATE FUNCTION vfloat8int2eq(vfloat8, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vfloat8, rightarg = int2, procedure = vfloat8int2eq, commutator = <> );
-CREATE FUNCTION vfloat8int2ne(vfloat8, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vfloat8, rightarg = int2, procedure = vfloat8int2ne, commutator = = );
-CREATE FUNCTION vfloat8int2lt(vfloat8, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vfloat8, rightarg = int2, procedure = vfloat8int2lt, commutator = >= );
-CREATE FUNCTION vfloat8int2le(vfloat8, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vfloat8, rightarg = int2, procedure = vfloat8int2le, commutator = > );
-CREATE FUNCTION vfloat8int4gt(vfloat8, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vfloat8, rightarg = int4, procedure = vfloat8int4gt, commutator = <= );
-CREATE FUNCTION vfloat8int4ge(vfloat8, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vfloat8, rightarg = int4, procedure = vfloat8int4ge, commutator = < );
-CREATE FUNCTION vfloat8int4eq(vfloat8, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vfloat8, rightarg = int4, procedure = vfloat8int4eq, commutator = <> );
-CREATE FUNCTION vfloat8int4ne(vfloat8, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vfloat8, rightarg = int4, procedure = vfloat8int4ne, commutator = = );
-CREATE FUNCTION vfloat8int4lt(vfloat8, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vfloat8, rightarg = int4, procedure = vfloat8int4lt, commutator = >= );
-CREATE FUNCTION vfloat8int4le(vfloat8, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vfloat8, rightarg = int4, procedure = vfloat8int4le, commutator = > );
-CREATE FUNCTION vfloat8int8gt(vfloat8, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vfloat8, rightarg = int8, procedure = vfloat8int8gt, commutator = <= );
-CREATE FUNCTION vfloat8int8ge(vfloat8, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vfloat8, rightarg = int8, procedure = vfloat8int8ge, commutator = < );
-CREATE FUNCTION vfloat8int8eq(vfloat8, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vfloat8, rightarg = int8, procedure = vfloat8int8eq, commutator = <> );
-CREATE FUNCTION vfloat8int8ne(vfloat8, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vfloat8, rightarg = int8, procedure = vfloat8int8ne, commutator = = );
-CREATE FUNCTION vfloat8int8lt(vfloat8, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vfloat8, rightarg = int8, procedure = vfloat8int8lt, commutator = >= );
-CREATE FUNCTION vfloat8int8le(vfloat8, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vfloat8, rightarg = int8, procedure = vfloat8int8le, commutator = > );
-CREATE FUNCTION vfloat8float4gt(vfloat8, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vfloat8, rightarg = float4, procedure = vfloat8float4gt, commutator = <= );
-CREATE FUNCTION vfloat8float4ge(vfloat8, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vfloat8, rightarg = float4, procedure = vfloat8float4ge, commutator = < );
-CREATE FUNCTION vfloat8float4eq(vfloat8, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vfloat8, rightarg = float4, procedure = vfloat8float4eq, commutator = <> );
-CREATE FUNCTION vfloat8float4ne(vfloat8, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vfloat8, rightarg = float4, procedure = vfloat8float4ne, commutator = = );
-CREATE FUNCTION vfloat8float4lt(vfloat8, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vfloat8, rightarg = float4, procedure = vfloat8float4lt, commutator = >= );
-CREATE FUNCTION vfloat8float4le(vfloat8, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vfloat8, rightarg = float4, procedure = vfloat8float4le, commutator = > );
-CREATE FUNCTION vfloat8float8gt(vfloat8, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR > ( leftarg = vfloat8, rightarg = float8, procedure = vfloat8float8gt, commutator = <= );
-CREATE FUNCTION vfloat8float8ge(vfloat8, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR >= ( leftarg = vfloat8, rightarg = float8, procedure = vfloat8float8ge, commutator = < );
-CREATE FUNCTION vfloat8float8eq(vfloat8, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR = ( leftarg = vfloat8, rightarg = float8, procedure = vfloat8float8eq, commutator = <> );
-CREATE FUNCTION vfloat8float8ne(vfloat8, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <> ( leftarg = vfloat8, rightarg = float8, procedure = vfloat8float8ne, commutator = = );
-CREATE FUNCTION vfloat8float8lt(vfloat8, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR < ( leftarg = vfloat8, rightarg = float8, procedure = vfloat8float8lt, commutator = >= );
-CREATE FUNCTION vfloat8float8le(vfloat8, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR <= ( leftarg = vfloat8, rightarg = float8, procedure = vfloat8float8le, commutator = > );
-
-
-CREATE FUNCTION vint2vint2pl(vint2, vint2) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR + ( leftarg = vint2, rightarg = vint2, procedure = vint2vint2pl, commutator = - );
-CREATE FUNCTION vint2vint2mi(vint2, vint2) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR - ( leftarg = vint2, rightarg = vint2, procedure = vint2vint2mi, commutator = + );
-CREATE FUNCTION vint2vint2mul(vint2, vint2) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR * ( leftarg = vint2, rightarg = vint2, procedure = vint2vint2mul, commutator = / );
-CREATE FUNCTION vint2vint2div(vint2, vint2) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR / ( leftarg = vint2, rightarg = vint2, procedure = vint2vint2div, commutator = * );
-
-CREATE FUNCTION vint4vint4pl(vint4, vint4) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR + ( leftarg = vint4, rightarg = vint4, procedure = vint4vint4pl, commutator = - );
-CREATE FUNCTION vint4vint4mi(vint4, vint4) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR - ( leftarg = vint4, rightarg = vint4, procedure = vint4vint4mi, commutator = + );
-CREATE FUNCTION vint4vint4mul(vint4, vint4) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR * ( leftarg = vint4, rightarg = vint4, procedure = vint4vint4mul, commutator = / );
-CREATE FUNCTION vint4vint4div(vint4, vint4) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR / ( leftarg = vint4, rightarg = vint4, procedure = vint4vint4div, commutator = * );
-
-CREATE FUNCTION vint8vint8pl(vint8, vint8) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR + ( leftarg = vint8, rightarg = vint8, procedure = vint8vint8pl, commutator = - );
-CREATE FUNCTION vint8vint8mi(vint8, vint8) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR - ( leftarg = vint8, rightarg = vint8, procedure = vint8vint8mi, commutator = + );
-CREATE FUNCTION vint8vint8mul(vint8, vint8) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR * ( leftarg = vint8, rightarg = vint8, procedure = vint8vint8mul, commutator = / );
-CREATE FUNCTION vint8vint8div(vint8, vint8) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR / ( leftarg = vint8, rightarg = vint8, procedure = vint8vint8div, commutator = * );
-
-
-CREATE FUNCTION vfloat4vfloat4pl(vfloat4, vfloat4) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR + ( leftarg = vfloat4, rightarg = vfloat4, procedure = vfloat4vfloat4pl, commutator = - );
-CREATE FUNCTION vfloat4vfloat4mi(vfloat4, vfloat4) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR - ( leftarg = vfloat4, rightarg = vfloat4, procedure = vfloat4vfloat4mi, commutator = + );
-CREATE FUNCTION vfloat4vfloat4mul(vfloat4, vfloat4) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR * ( leftarg = vfloat4, rightarg = vfloat4, procedure = vfloat4vfloat4mul, commutator = / );
-CREATE FUNCTION vfloat4vfloat4div(vfloat4, vfloat4) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR / ( leftarg = vfloat4, rightarg = vfloat4, procedure = vfloat4vfloat4div, commutator = * );
-
-
-
-CREATE FUNCTION vfloat8vfloat8pl(vfloat8, vfloat8) RETURNS vfloat8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR + ( leftarg = vfloat8, rightarg = vfloat8, procedure = vfloat8vfloat8pl, commutator = - );
-CREATE FUNCTION vfloat8vfloat8mi(vfloat8, vfloat8) RETURNS vfloat8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR - ( leftarg = vfloat8, rightarg = vfloat8, procedure = vfloat8vfloat8mi, commutator = + );
-CREATE FUNCTION vfloat8vfloat8mul(vfloat8, vfloat8) RETURNS vfloat8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR * ( leftarg = vfloat8, rightarg = vfloat8, procedure = vfloat8vfloat8mul, commutator = / );
-CREATE FUNCTION vfloat8vfloat8div(vfloat8, vfloat8) RETURNS vfloat8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR / ( leftarg = vfloat8, rightarg = vfloat8, procedure = vfloat8vfloat8div, commutator = * );
-
-
-
-
-
-CREATE FUNCTION vint2int2pl(vint2, int2) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR + ( leftarg = vint2, rightarg = int2, procedure = vint2int2pl, commutator = - );
-CREATE FUNCTION vint2int2mi(vint2, int2) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR - ( leftarg = vint2, rightarg = int2, procedure = vint2int2mi, commutator = + );
-CREATE FUNCTION vint2int2mul(vint2, int2) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR * ( leftarg = vint2, rightarg = int2, procedure = vint2int2mul, commutator = / );
-CREATE FUNCTION vint2int2div(vint2, int2) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR / ( leftarg = vint2, rightarg = int2, procedure = vint2int2div, commutator = * );
-CREATE FUNCTION vint2int4pl(vint2, int4) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR + ( leftarg = vint2, rightarg = int4, procedure = vint2int4pl, commutator = - );
-CREATE FUNCTION vint2int4mi(vint2, int4) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR - ( leftarg = vint2, rightarg = int4, procedure = vint2int4mi, commutator = + );
-CREATE FUNCTION vint2int4mul(vint2, int4) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR * ( leftarg = vint2, rightarg = int4, procedure = vint2int4mul, commutator = / );
-CREATE FUNCTION vint2int4div(vint2, int4) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR / ( leftarg = vint2, rightarg = int4, procedure = vint2int4div, commutator = * );
-CREATE FUNCTION vint2int8pl(vint2, int8) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR + ( leftarg = vint2, rightarg = int8, procedure = vint2int8pl, commutator = - );
-CREATE FUNCTION vint2int8mi(vint2, int8) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR - ( leftarg = vint2, rightarg = int8, procedure = vint2int8mi, commutator = + );
-CREATE FUNCTION vint2int8mul(vint2, int8) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR * ( leftarg = vint2, rightarg = int8, procedure = vint2int8mul, commutator = / );
-CREATE FUNCTION vint2int8div(vint2, int8) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR / ( leftarg = vint2, rightarg = int8, procedure = vint2int8div, commutator = * );
-CREATE FUNCTION vint2float4pl(vint2, float4) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR + ( leftarg = vint2, rightarg = float4, procedure = vint2float4pl, commutator = - );
-CREATE FUNCTION vint2float4mi(vint2, float4) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR - ( leftarg = vint2, rightarg = float4, procedure = vint2float4mi, commutator = + );
-CREATE FUNCTION vint2float4mul(vint2, float4) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR * ( leftarg = vint2, rightarg = float4, procedure = vint2float4mul, commutator = / );
-CREATE FUNCTION vint2float4div(vint2, float4) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR / ( leftarg = vint2, rightarg = float4, procedure = vint2float4div, commutator = * );
-CREATE FUNCTION vint2float8pl(vint2, float8) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR + ( leftarg = vint2, rightarg = float8, procedure = vint2float8pl, commutator = - );
-CREATE FUNCTION vint2float8mi(vint2, float8) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR - ( leftarg = vint2, rightarg = float8, procedure = vint2float8mi, commutator = + );
-CREATE FUNCTION vint2float8mul(vint2, float8) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR * ( leftarg = vint2, rightarg = float8, procedure = vint2float8mul, commutator = / );
-CREATE FUNCTION vint2float8div(vint2, float8) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR / ( leftarg = vint2, rightarg = float8, procedure = vint2float8div, commutator = * );
-
-CREATE FUNCTION vint4int2pl(vint4, int2) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR + ( leftarg = vint4, rightarg = int2, procedure = vint4int2pl, commutator = - );
-CREATE FUNCTION vint4int2mi(vint4, int2) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR - ( leftarg = vint4, rightarg = int2, procedure = vint4int2mi, commutator = + );
-CREATE FUNCTION vint4int2mul(vint4, int2) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR * ( leftarg = vint4, rightarg = int2, procedure = vint4int2mul, commutator = / );
-CREATE FUNCTION vint4int2div(vint4, int2) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR / ( leftarg = vint4, rightarg = int2, procedure = vint4int2div, commutator = * );
-CREATE FUNCTION vint4int4pl(vint4, int4) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR + ( leftarg = vint4, rightarg = int4, procedure = vint4int4pl, commutator = - );
-CREATE FUNCTION vint4int4mi(vint4, int4) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR - ( leftarg = vint4, rightarg = int4, procedure = vint4int4mi, commutator = + );
-CREATE FUNCTION vint4int4mul(vint4, int4) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR * ( leftarg = vint4, rightarg = int4, procedure = vint4int4mul, commutator = / );
-CREATE FUNCTION vint4int4div(vint4, int4) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR / ( leftarg = vint4, rightarg = int4, procedure = vint4int4div, commutator = * );
-CREATE FUNCTION vint4int8pl(vint4, int8) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR + ( leftarg = vint4, rightarg = int8, procedure = vint4int8pl, commutator = - );
-CREATE FUNCTION vint4int8mi(vint4, int8) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR - ( leftarg = vint4, rightarg = int8, procedure = vint4int8mi, commutator = + );
-CREATE FUNCTION vint4int8mul(vint4, int8) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR * ( leftarg = vint4, rightarg = int8, procedure = vint4int8mul, commutator = / );
-CREATE FUNCTION vint4int8div(vint4, int8) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR / ( leftarg = vint4, rightarg = int8, procedure = vint4int8div, commutator = * );
-CREATE FUNCTION vint4float4pl(vint4, float4) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR + ( leftarg = vint4, rightarg = float4, procedure = vint4float4pl, commutator = - );
-CREATE FUNCTION vint4float4mi(vint4, float4) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR - ( leftarg = vint4, rightarg = float4, procedure = vint4float4mi, commutator = + );
-CREATE FUNCTION vint4float4mul(vint4, float4) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR * ( leftarg = vint4, rightarg = float4, procedure = vint4float4mul, commutator = / );
-CREATE FUNCTION vint4float4div(vint4, float4) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR / ( leftarg = vint4, rightarg = float4, procedure = vint4float4div, commutator = * );
-CREATE FUNCTION vint4float8pl(vint4, float8) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR + ( leftarg = vint4, rightarg = float8, procedure = vint4float8pl, commutator = - );
-CREATE FUNCTION vint4float8mi(vint4, float8) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR - ( leftarg = vint4, rightarg = float8, procedure = vint4float8mi, commutator = + );
-CREATE FUNCTION vint4float8mul(vint4, float8) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR * ( leftarg = vint4, rightarg = float8, procedure = vint4float8mul, commutator = / );
-CREATE FUNCTION vint4float8div(vint4, float8) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR / ( leftarg = vint4, rightarg = float8, procedure = vint4float8div, commutator = * );
-
-CREATE FUNCTION vint8int2pl(vint8, int2) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR + ( leftarg = vint8, rightarg = int2, procedure = vint8int2pl, commutator = - );
-CREATE FUNCTION vint8int2mi(vint8, int2) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR - ( leftarg = vint8, rightarg = int2, procedure = vint8int2mi, commutator = + );
-CREATE FUNCTION vint8int2mul(vint8, int2) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR * ( leftarg = vint8, rightarg = int2, procedure = vint8int2mul, commutator = / );
-CREATE FUNCTION vint8int2div(vint8, int2) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR / ( leftarg = vint8, rightarg = int2, procedure = vint8int2div, commutator = * );
-CREATE FUNCTION vint8int4pl(vint8, int4) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR + ( leftarg = vint8, rightarg = int4, procedure = vint8int4pl, commutator = - );
-CREATE FUNCTION vint8int4mi(vint8, int4) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR - ( leftarg = vint8, rightarg = int4, procedure = vint8int4mi, commutator = + );
-CREATE FUNCTION vint8int4mul(vint8, int4) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR * ( leftarg = vint8, rightarg = int4, procedure = vint8int4mul, commutator = / );
-CREATE FUNCTION vint8int4div(vint8, int4) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR / ( leftarg = vint8, rightarg = int4, procedure = vint8int4div, commutator = * );
-CREATE FUNCTION vint8int8pl(vint8, int8) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR + ( leftarg = vint8, rightarg = int8, procedure = vint8int8pl, commutator = - );
-CREATE FUNCTION vint8int8mi(vint8, int8) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR - ( leftarg = vint8, rightarg = int8, procedure = vint8int8mi, commutator = + );
-CREATE FUNCTION vint8int8mul(vint8, int8) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR * ( leftarg = vint8, rightarg = int8, procedure = vint8int8mul, commutator = / );
-CREATE FUNCTION vint8int8div(vint8, int8) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR / ( leftarg = vint8, rightarg = int8, procedure = vint8int8div, commutator = * );
-CREATE FUNCTION vint8float4pl(vint8, float4) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR + ( leftarg = vint8, rightarg = float4, procedure = vint8float4pl, commutator = - );
-CREATE FUNCTION vint8float4mi(vint8, float4) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR - ( leftarg = vint8, rightarg = float4, procedure = vint8float4mi, commutator = + );
-CREATE FUNCTION vint8float4mul(vint8, float4) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR * ( leftarg = vint8, rightarg = float4, procedure = vint8float4mul, commutator = / );
-CREATE FUNCTION vint8float4div(vint8, float4) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR / ( leftarg = vint8, rightarg = float4, procedure = vint8float4div, commutator = * );
-CREATE FUNCTION vint8float8pl(vint8, float8) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR + ( leftarg = vint8, rightarg = float8, procedure = vint8float8pl, commutator = - );
-CREATE FUNCTION vint8float8mi(vint8, float8) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR - ( leftarg = vint8, rightarg = float8, procedure = vint8float8mi, commutator = + );
-CREATE FUNCTION vint8float8mul(vint8, float8) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR * ( leftarg = vint8, rightarg = float8, procedure = vint8float8mul, commutator = / );
-CREATE FUNCTION vint8float8div(vint8, float8) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR / ( leftarg = vint8, rightarg = float8, procedure = vint8float8div, commutator = * );
-
-
-
-CREATE FUNCTION vfloat4int2pl(vfloat4, int2) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR + ( leftarg = vfloat4, rightarg = int2, procedure = vfloat4int2pl, commutator = - );
-CREATE FUNCTION vfloat4int2mi(vfloat4, int2) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR - ( leftarg = vfloat4, rightarg = int2, procedure = vfloat4int2mi, commutator = + );
-CREATE FUNCTION vfloat4int2mul(vfloat4, int2) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR * ( leftarg = vfloat4, rightarg = int2, procedure = vfloat4int2mul, commutator = / );
-CREATE FUNCTION vfloat4int2div(vfloat4, int2) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR / ( leftarg = vfloat4, rightarg = int2, procedure = vfloat4int2div, commutator = * );
-CREATE FUNCTION vfloat4int4pl(vfloat4, int4) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR + ( leftarg = vfloat4, rightarg = int4, procedure = vfloat4int4pl, commutator = - );
-CREATE FUNCTION vfloat4int4mi(vfloat4, int4) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR - ( leftarg = vfloat4, rightarg = int4, procedure = vfloat4int4mi, commutator = + );
-CREATE FUNCTION vfloat4int4mul(vfloat4, int4) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR * ( leftarg = vfloat4, rightarg = int4, procedure = vfloat4int4mul, commutator = / );
-CREATE FUNCTION vfloat4int4div(vfloat4, int4) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR / ( leftarg = vfloat4, rightarg = int4, procedure = vfloat4int4div, commutator = * );
-CREATE FUNCTION vfloat4int8pl(vfloat4, int8) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR + ( leftarg = vfloat4, rightarg = int8, procedure = vfloat4int8pl, commutator = - );
-CREATE FUNCTION vfloat4int8mi(vfloat4, int8) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR - ( leftarg = vfloat4, rightarg = int8, procedure = vfloat4int8mi, commutator = + );
-CREATE FUNCTION vfloat4int8mul(vfloat4, int8) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR * ( leftarg = vfloat4, rightarg = int8, procedure = vfloat4int8mul, commutator = / );
-CREATE FUNCTION vfloat4int8div(vfloat4, int8) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR / ( leftarg = vfloat4, rightarg = int8, procedure = vfloat4int8div, commutator = * );
-CREATE FUNCTION vfloat4float4pl(vfloat4, float4) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR + ( leftarg = vfloat4, rightarg = float4, procedure = vfloat4float4pl, commutator = - );
-CREATE FUNCTION vfloat4float4mi(vfloat4, float4) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR - ( leftarg = vfloat4, rightarg = float4, procedure = vfloat4float4mi, commutator = + );
-CREATE FUNCTION vfloat4float4mul(vfloat4, float4) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR * ( leftarg = vfloat4, rightarg = float4, procedure = vfloat4float4mul, commutator = / );
-CREATE FUNCTION vfloat4float4div(vfloat4, float4) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR / ( leftarg = vfloat4, rightarg = float4, procedure = vfloat4float4div, commutator = * );
-CREATE FUNCTION vfloat4float8pl(vfloat4, float8) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR + ( leftarg = vfloat4, rightarg = float8, procedure = vfloat4float8pl, commutator = - );
-CREATE FUNCTION vfloat4float8mi(vfloat4, float8) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR - ( leftarg = vfloat4, rightarg = float8, procedure = vfloat4float8mi, commutator = + );
-CREATE FUNCTION vfloat4float8mul(vfloat4, float8) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR * ( leftarg = vfloat4, rightarg = float8, procedure = vfloat4float8mul, commutator = / );
-CREATE FUNCTION vfloat4float8div(vfloat4, float8) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR / ( leftarg = vfloat4, rightarg = float8, procedure = vfloat4float8div, commutator = * );
-
-
-
-
-CREATE FUNCTION vfloat8int2pl(vfloat8, int2) RETURNS vfloat8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR + ( leftarg = vfloat8, rightarg = int2, procedure = vfloat8int2pl, commutator = - );
-CREATE FUNCTION vfloat8int2mi(vfloat8, int2) RETURNS vfloat8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR - ( leftarg = vfloat8, rightarg = int2, procedure = vfloat8int2mi, commutator = + );
-CREATE FUNCTION vfloat8int2mul(vfloat8, int2) RETURNS vfloat8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR * ( leftarg = vfloat8, rightarg = int2, procedure = vfloat8int2mul, commutator = / );
-CREATE FUNCTION vfloat8int2div(vfloat8, int2) RETURNS vfloat8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR / ( leftarg = vfloat8, rightarg = int2, procedure = vfloat8int2div, commutator = * );
-CREATE FUNCTION vfloat8int4pl(vfloat8, int4) RETURNS vfloat8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR + ( leftarg = vfloat8, rightarg = int4, procedure = vfloat8int4pl, commutator = - );
-CREATE FUNCTION vfloat8int4mi(vfloat8, int4) RETURNS vfloat8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR - ( leftarg = vfloat8, rightarg = int4, procedure = vfloat8int4mi, commutator = + );
-CREATE FUNCTION vfloat8int4mul(vfloat8, int4) RETURNS vfloat8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR * ( leftarg = vfloat8, rightarg = int4, procedure = vfloat8int4mul, commutator = / );
-CREATE FUNCTION vfloat8int4div(vfloat8, int4) RETURNS vfloat8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR / ( leftarg = vfloat8, rightarg = int4, procedure = vfloat8int4div, commutator = * );
-CREATE FUNCTION vfloat8int8pl(vfloat8, int8) RETURNS vfloat8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR + ( leftarg = vfloat8, rightarg = int8, procedure = vfloat8int8pl, commutator = - );
-CREATE FUNCTION vfloat8int8mi(vfloat8, int8) RETURNS vfloat8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR - ( leftarg = vfloat8, rightarg = int8, procedure = vfloat8int8mi, commutator = + );
-CREATE FUNCTION vfloat8int8mul(vfloat8, int8) RETURNS vfloat8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR * ( leftarg = vfloat8, rightarg = int8, procedure = vfloat8int8mul, commutator = / );
-CREATE FUNCTION vfloat8int8div(vfloat8, int8) RETURNS vfloat8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
-CREATE OPERATOR / ( leftarg = vfloat8, rightarg = int8, procedure = vfloat8int8div, commutator = * );
-CREATE FUNC
<TRUNCATED>
[7/9] incubator-hawq git commit: HAWQ-1612. Implement vectorized
aggregate functions, such as avg/sum/count.
Posted by rl...@apache.org.
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/ce2814d4/contrib/vexecutor/create_udv.sql
----------------------------------------------------------------------
diff --git a/contrib/vexecutor/create_udv.sql b/contrib/vexecutor/create_udv.sql
new file mode 100644
index 0000000..41b0220
--- /dev/null
+++ b/contrib/vexecutor/create_udv.sql
@@ -0,0 +1,1139 @@
+--drop agg functions
+--drop the previous funcitons
+DROP AGGREGATE IF EXISTS sum(vint2);
+DROP AGGREGATE IF EXISTS sum(vint4);
+DROP AGGREGATE IF EXISTS sum(vint8);
+DROP AGGREGATE IF EXISTS sum(vfloat4);
+DROP AGGREGATE IF EXISTS sum(vfloat8);
+
+DROP AGGREGATE IF EXISTS avg(vint2);
+DROP AGGREGATE IF EXISTS avg(vint4);
+DROP AGGREGATE IF EXISTS avg(vint8);
+DROP AGGREGATE IF EXISTS avg(vfloat4);
+DROP AGGREGATE IF EXISTS avg(vfloat8);
+
+DROP AGGREGATE IF EXISTS count(vint2);
+DROP AGGREGATE IF EXISTS count(vint4);
+DROP AGGREGATE IF EXISTS count(vint8);
+DROP AGGREGATE IF EXISTS count(vfloat4);
+DROP AGGREGATE IF EXISTS count(vfloat8);
+
+DROP AGGREGATE IF EXISTS veccount(*);
+
+DROP FUNCTION IF EXISTS vint2_accum(int8, vint2);
+DROP FUNCTION IF EXISTS vint4_accum(int8, vint4);
+DROP FUNCTION IF EXISTS vint8_accum(numeric, vint8);
+DROP FUNCTION IF EXISTS vfloat4_accum(float4, vfloat4);
+DROP FUNCTION IF EXISTS vfloat8_accum(float8, vfloat8);
+
+DROP FUNCTION IF EXISTS vint2_avg_accum(bytea, vint2);
+DROP FUNCTION IF EXISTS vint4_avg_accum(bytea, vint4);
+DROP FUNCTION IF EXISTS vint8_avg_accum(bytea, vint8);
+DROP FUNCTION IF EXISTS vfloat4_avg_accum(bytea, vfloat4);
+DROP FUNCTION IF EXISTS vfloat8_avg_accum(bytea, vfloat8);
+
+DROP FUNCTION IF EXISTS vint2_inc(int8, vint2);
+DROP FUNCTION IF EXISTS vint4_inc(int8, vint4);
+DROP FUNCTION IF EXISTS vint8_inc(int8, vint8);
+DROP FUNCTION IF EXISTS vfloat4_inc(int8, vfloat4);
+DROP FUNCTION IF EXISTS vfloat8_inc(int8, vfloat8);
+
+DROP FUNCTION IF EXISTS vec_inc_any(int8);
+
+-- drop types first
+drop type vint2 cascade;
+drop type vint4 cascade;
+drop type vint8 cascade;
+drop type vfloat8 cascade;
+drop type vfloat4 cascade;
+drop type vbool cascade;
+drop type vdateadt cascade;
+
+
+
+-- create vectorized types
+
+CREATE TYPE vint2;
+CREATE FUNCTION vint2in(cstring) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION vint2out(vint2) RETURNS cstring AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE TYPE vint2 ( INPUT = vint2in, OUTPUT = vint2out, element = int2, storage=external );
+
+
+CREATE TYPE vint4;
+CREATE FUNCTION vint4in(cstring) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION vint4out(vint4) RETURNS cstring AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE TYPE vint4 ( INPUT = vint4in, OUTPUT = vint4out, element = int4, storage=external );
+
+CREATE TYPE vint8;
+CREATE FUNCTION vint8in(cstring) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION vint8out(vint8) RETURNS cstring AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE TYPE vint8 ( INPUT = vint8in, OUTPUT = vint8out, element = int8, storage=external );
+
+
+CREATE TYPE vfloat4;
+CREATE FUNCTION vfloat4in(cstring) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION vfloat4out(vfloat4) RETURNS cstring AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE TYPE vfloat4 ( INPUT = vfloat4in, OUTPUT = vfloat4out, element = float4, storage=external );
+
+
+CREATE TYPE vfloat8;
+CREATE FUNCTION vfloat8in(cstring) RETURNS vfloat8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION vfloat8out(vfloat8) RETURNS cstring AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE TYPE vfloat8 ( INPUT = vfloat8in, OUTPUT = vfloat8out, element = float8, storage=external );
+
+
+CREATE TYPE vbool;
+CREATE FUNCTION vboolin(cstring) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION vboolout(vbool) RETURNS cstring AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE TYPE vbool ( INPUT = vboolin, OUTPUT = vboolout, element = bool, storage=external );
+
+CREATE TYPE vdateadt;
+CREATE FUNCTION vdateadtin(cstring) RETURNS vdateadt as 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION vdateadtout(vdateadt) RETURNS cstring AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE TYPE vdateadt ( INPUT = vdateadtin, OUTPUT = vdateadtout, element = date , storage=external);
+
+-- create operators for the vectorized types
+
+CREATE FUNCTION vint2vint2gt(vint2, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vint2, rightarg = vint2, procedure = vint2vint2gt, commutator = <= );
+CREATE FUNCTION vint2vint2ge(vint2, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vint2, rightarg = vint2, procedure = vint2vint2ge, commutator = < );
+CREATE FUNCTION vint2vint2eq(vint2, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vint2, rightarg = vint2, procedure = vint2vint2eq, commutator = <> );
+CREATE FUNCTION vint2vint2ne(vint2, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vint2, rightarg = vint2, procedure = vint2vint2ne, commutator = = );
+CREATE FUNCTION vint2vint2lt(vint2, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vint2, rightarg = vint2, procedure = vint2vint2lt, commutator = >= );
+CREATE FUNCTION vint2vint2le(vint2, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vint2, rightarg = vint2, procedure = vint2vint2le, commutator = > );
+CREATE FUNCTION vint2vint4gt(vint2, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vint2, rightarg = vint4, procedure = vint2vint4gt, commutator = <= );
+CREATE FUNCTION vint2vint4ge(vint2, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vint2, rightarg = vint4, procedure = vint2vint4ge, commutator = < );
+CREATE FUNCTION vint2vint4eq(vint2, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vint2, rightarg = vint4, procedure = vint2vint4eq, commutator = <> );
+CREATE FUNCTION vint2vint4ne(vint2, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vint2, rightarg = vint4, procedure = vint2vint4ne, commutator = = );
+CREATE FUNCTION vint2vint4lt(vint2, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vint2, rightarg = vint4, procedure = vint2vint4lt, commutator = >= );
+CREATE FUNCTION vint2vint4le(vint2, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vint2, rightarg = vint4, procedure = vint2vint4le, commutator = > );
+CREATE FUNCTION vint2vint8gt(vint2, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vint2, rightarg = vint8, procedure = vint2vint8gt, commutator = <= );
+CREATE FUNCTION vint2vint8ge(vint2, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vint2, rightarg = vint8, procedure = vint2vint8ge, commutator = < );
+CREATE FUNCTION vint2vint8eq(vint2, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vint2, rightarg = vint8, procedure = vint2vint8eq, commutator = <> );
+CREATE FUNCTION vint2vint8ne(vint2, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vint2, rightarg = vint8, procedure = vint2vint8ne, commutator = = );
+CREATE FUNCTION vint2vint8lt(vint2, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vint2, rightarg = vint8, procedure = vint2vint8lt, commutator = >= );
+CREATE FUNCTION vint2vint8le(vint2, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vint2, rightarg = vint8, procedure = vint2vint8le, commutator = > );
+CREATE FUNCTION vint2vfloat4gt(vint2, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vint2, rightarg = vfloat4, procedure = vint2vfloat4gt, commutator = <= );
+CREATE FUNCTION vint2vfloat4ge(vint2, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vint2, rightarg = vfloat4, procedure = vint2vfloat4ge, commutator = < );
+CREATE FUNCTION vint2vfloat4eq(vint2, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vint2, rightarg = vfloat4, procedure = vint2vfloat4eq, commutator = <> );
+CREATE FUNCTION vint2vfloat4ne(vint2, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vint2, rightarg = vfloat4, procedure = vint2vfloat4ne, commutator = = );
+CREATE FUNCTION vint2vfloat4lt(vint2, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vint2, rightarg = vfloat4, procedure = vint2vfloat4lt, commutator = >= );
+CREATE FUNCTION vint2vfloat4le(vint2, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vint2, rightarg = vfloat4, procedure = vint2vfloat4le, commutator = > );
+CREATE FUNCTION vint2vfloat8gt(vint2, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vint2, rightarg = vfloat8, procedure = vint2vfloat8gt, commutator = <= );
+CREATE FUNCTION vint2vfloat8ge(vint2, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vint2, rightarg = vfloat8, procedure = vint2vfloat8ge, commutator = < );
+CREATE FUNCTION vint2vfloat8eq(vint2, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vint2, rightarg = vfloat8, procedure = vint2vfloat8eq, commutator = <> );
+CREATE FUNCTION vint2vfloat8ne(vint2, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vint2, rightarg = vfloat8, procedure = vint2vfloat8ne, commutator = = );
+CREATE FUNCTION vint2vfloat8lt(vint2, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vint2, rightarg = vfloat8, procedure = vint2vfloat8lt, commutator = >= );
+CREATE FUNCTION vint2vfloat8le(vint2, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vint2, rightarg = vfloat8, procedure = vint2vfloat8le, commutator = > );
+CREATE FUNCTION vint2int2gt(vint2, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vint2, rightarg = int2, procedure = vint2int2gt, commutator = <= );
+CREATE FUNCTION vint2int2ge(vint2, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vint2, rightarg = int2, procedure = vint2int2ge, commutator = < );
+CREATE FUNCTION vint2int2eq(vint2, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vint2, rightarg = int2, procedure = vint2int2eq, commutator = <> );
+CREATE FUNCTION vint2int2ne(vint2, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vint2, rightarg = int2, procedure = vint2int2ne, commutator = = );
+CREATE FUNCTION vint2int2lt(vint2, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vint2, rightarg = int2, procedure = vint2int2lt, commutator = >= );
+CREATE FUNCTION vint2int2le(vint2, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vint2, rightarg = int2, procedure = vint2int2le, commutator = > );
+CREATE FUNCTION vint2int4gt(vint2, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vint2, rightarg = int4, procedure = vint2int4gt, commutator = <= );
+CREATE FUNCTION vint2int4ge(vint2, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vint2, rightarg = int4, procedure = vint2int4ge, commutator = < );
+CREATE FUNCTION vint2int4eq(vint2, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vint2, rightarg = int4, procedure = vint2int4eq, commutator = <> );
+CREATE FUNCTION vint2int4ne(vint2, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vint2, rightarg = int4, procedure = vint2int4ne, commutator = = );
+CREATE FUNCTION vint2int4lt(vint2, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vint2, rightarg = int4, procedure = vint2int4lt, commutator = >= );
+CREATE FUNCTION vint2int4le(vint2, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vint2, rightarg = int4, procedure = vint2int4le, commutator = > );
+CREATE FUNCTION vint2int8gt(vint2, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vint2, rightarg = int8, procedure = vint2int8gt, commutator = <= );
+CREATE FUNCTION vint2int8ge(vint2, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vint2, rightarg = int8, procedure = vint2int8ge, commutator = < );
+CREATE FUNCTION vint2int8eq(vint2, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vint2, rightarg = int8, procedure = vint2int8eq, commutator = <> );
+CREATE FUNCTION vint2int8ne(vint2, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vint2, rightarg = int8, procedure = vint2int8ne, commutator = = );
+CREATE FUNCTION vint2int8lt(vint2, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vint2, rightarg = int8, procedure = vint2int8lt, commutator = >= );
+CREATE FUNCTION vint2int8le(vint2, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vint2, rightarg = int8, procedure = vint2int8le, commutator = > );
+CREATE FUNCTION vint2float4gt(vint2, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vint2, rightarg = float4, procedure = vint2float4gt, commutator = <= );
+CREATE FUNCTION vint2float4ge(vint2, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vint2, rightarg = float4, procedure = vint2float4ge, commutator = < );
+CREATE FUNCTION vint2float4eq(vint2, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vint2, rightarg = float4, procedure = vint2float4eq, commutator = <> );
+CREATE FUNCTION vint2float4ne(vint2, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vint2, rightarg = float4, procedure = vint2float4ne, commutator = = );
+CREATE FUNCTION vint2float4lt(vint2, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vint2, rightarg = float4, procedure = vint2float4lt, commutator = >= );
+CREATE FUNCTION vint2float4le(vint2, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vint2, rightarg = float4, procedure = vint2float4le, commutator = > );
+CREATE FUNCTION vint2float8gt(vint2, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vint2, rightarg = float8, procedure = vint2float8gt, commutator = <= );
+CREATE FUNCTION vint2float8ge(vint2, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vint2, rightarg = float8, procedure = vint2float8ge, commutator = < );
+CREATE FUNCTION vint2float8eq(vint2, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vint2, rightarg = float8, procedure = vint2float8eq, commutator = <> );
+CREATE FUNCTION vint2float8ne(vint2, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vint2, rightarg = float8, procedure = vint2float8ne, commutator = = );
+CREATE FUNCTION vint2float8lt(vint2, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vint2, rightarg = float8, procedure = vint2float8lt, commutator = >= );
+CREATE FUNCTION vint2float8le(vint2, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vint2, rightarg = float8, procedure = vint2float8le, commutator = > );
+
+CREATE FUNCTION vint4vint2gt(vint4, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vint4, rightarg = vint2, procedure = vint4vint2gt, commutator = <= );
+CREATE FUNCTION vint4vint2ge(vint4, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vint4, rightarg = vint2, procedure = vint4vint2ge, commutator = < );
+CREATE FUNCTION vint4vint2eq(vint4, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vint4, rightarg = vint2, procedure = vint4vint2eq, commutator = <> );
+CREATE FUNCTION vint4vint2ne(vint4, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vint4, rightarg = vint2, procedure = vint4vint2ne, commutator = = );
+CREATE FUNCTION vint4vint2lt(vint4, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vint4, rightarg = vint2, procedure = vint4vint2lt, commutator = >= );
+CREATE FUNCTION vint4vint2le(vint4, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vint4, rightarg = vint2, procedure = vint4vint2le, commutator = > );
+CREATE FUNCTION vint4vint4gt(vint4, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vint4, rightarg = vint4, procedure = vint4vint4gt, commutator = <= );
+CREATE FUNCTION vint4vint4ge(vint4, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vint4, rightarg = vint4, procedure = vint4vint4ge, commutator = < );
+CREATE FUNCTION vint4vint4eq(vint4, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vint4, rightarg = vint4, procedure = vint4vint4eq, commutator = <> );
+CREATE FUNCTION vint4vint4ne(vint4, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vint4, rightarg = vint4, procedure = vint4vint4ne, commutator = = );
+CREATE FUNCTION vint4vint4lt(vint4, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vint4, rightarg = vint4, procedure = vint4vint4lt, commutator = >= );
+CREATE FUNCTION vint4vint4le(vint4, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vint4, rightarg = vint4, procedure = vint4vint4le, commutator = > );
+CREATE FUNCTION vint4vint8gt(vint4, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vint4, rightarg = vint8, procedure = vint4vint8gt, commutator = <= );
+CREATE FUNCTION vint4vint8ge(vint4, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vint4, rightarg = vint8, procedure = vint4vint8ge, commutator = < );
+CREATE FUNCTION vint4vint8eq(vint4, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vint4, rightarg = vint8, procedure = vint4vint8eq, commutator = <> );
+CREATE FUNCTION vint4vint8ne(vint4, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vint4, rightarg = vint8, procedure = vint4vint8ne, commutator = = );
+CREATE FUNCTION vint4vint8lt(vint4, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vint4, rightarg = vint8, procedure = vint4vint8lt, commutator = >= );
+CREATE FUNCTION vint4vint8le(vint4, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vint4, rightarg = vint8, procedure = vint4vint8le, commutator = > );
+CREATE FUNCTION vint4vfloat4gt(vint4, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vint4, rightarg = vfloat4, procedure = vint4vfloat4gt, commutator = <= );
+CREATE FUNCTION vint4vfloat4ge(vint4, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vint4, rightarg = vfloat4, procedure = vint4vfloat4ge, commutator = < );
+CREATE FUNCTION vint4vfloat4eq(vint4, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vint4, rightarg = vfloat4, procedure = vint4vfloat4eq, commutator = <> );
+CREATE FUNCTION vint4vfloat4ne(vint4, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vint4, rightarg = vfloat4, procedure = vint4vfloat4ne, commutator = = );
+CREATE FUNCTION vint4vfloat4lt(vint4, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vint4, rightarg = vfloat4, procedure = vint4vfloat4lt, commutator = >= );
+CREATE FUNCTION vint4vfloat4le(vint4, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vint4, rightarg = vfloat4, procedure = vint4vfloat4le, commutator = > );
+CREATE FUNCTION vint4vfloat8gt(vint4, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vint4, rightarg = vfloat8, procedure = vint4vfloat8gt, commutator = <= );
+CREATE FUNCTION vint4vfloat8ge(vint4, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vint4, rightarg = vfloat8, procedure = vint4vfloat8ge, commutator = < );
+CREATE FUNCTION vint4vfloat8eq(vint4, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vint4, rightarg = vfloat8, procedure = vint4vfloat8eq, commutator = <> );
+CREATE FUNCTION vint4vfloat8ne(vint4, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vint4, rightarg = vfloat8, procedure = vint4vfloat8ne, commutator = = );
+CREATE FUNCTION vint4vfloat8lt(vint4, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vint4, rightarg = vfloat8, procedure = vint4vfloat8lt, commutator = >= );
+CREATE FUNCTION vint4vfloat8le(vint4, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vint4, rightarg = vfloat8, procedure = vint4vfloat8le, commutator = > );
+CREATE FUNCTION vint4int2gt(vint4, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vint4, rightarg = int2, procedure = vint4int2gt, commutator = <= );
+CREATE FUNCTION vint4int2ge(vint4, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vint4, rightarg = int2, procedure = vint4int2ge, commutator = < );
+CREATE FUNCTION vint4int2eq(vint4, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vint4, rightarg = int2, procedure = vint4int2eq, commutator = <> );
+CREATE FUNCTION vint4int2ne(vint4, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vint4, rightarg = int2, procedure = vint4int2ne, commutator = = );
+CREATE FUNCTION vint4int2lt(vint4, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vint4, rightarg = int2, procedure = vint4int2lt, commutator = >= );
+CREATE FUNCTION vint4int2le(vint4, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vint4, rightarg = int2, procedure = vint4int2le, commutator = > );
+CREATE FUNCTION vint4int4gt(vint4, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vint4, rightarg = int4, procedure = vint4int4gt, commutator = <= );
+CREATE FUNCTION vint4int4ge(vint4, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vint4, rightarg = int4, procedure = vint4int4ge, commutator = < );
+CREATE FUNCTION vint4int4eq(vint4, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vint4, rightarg = int4, procedure = vint4int4eq, commutator = <> );
+CREATE FUNCTION vint4int4ne(vint4, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vint4, rightarg = int4, procedure = vint4int4ne, commutator = = );
+CREATE FUNCTION vint4int4lt(vint4, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vint4, rightarg = int4, procedure = vint4int4lt, commutator = >= );
+CREATE FUNCTION vint4int4le(vint4, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vint4, rightarg = int4, procedure = vint4int4le, commutator = > );
+CREATE FUNCTION vint4int8gt(vint4, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vint4, rightarg = int8, procedure = vint4int8gt, commutator = <= );
+CREATE FUNCTION vint4int8ge(vint4, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vint4, rightarg = int8, procedure = vint4int8ge, commutator = < );
+CREATE FUNCTION vint4int8eq(vint4, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vint4, rightarg = int8, procedure = vint4int8eq, commutator = <> );
+CREATE FUNCTION vint4int8ne(vint4, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vint4, rightarg = int8, procedure = vint4int8ne, commutator = = );
+CREATE FUNCTION vint4int8lt(vint4, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vint4, rightarg = int8, procedure = vint4int8lt, commutator = >= );
+CREATE FUNCTION vint4int8le(vint4, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vint4, rightarg = int8, procedure = vint4int8le, commutator = > );
+CREATE FUNCTION vint4float4gt(vint4, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vint4, rightarg = float4, procedure = vint4float4gt, commutator = <= );
+CREATE FUNCTION vint4float4ge(vint4, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vint4, rightarg = float4, procedure = vint4float4ge, commutator = < );
+CREATE FUNCTION vint4float4eq(vint4, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vint4, rightarg = float4, procedure = vint4float4eq, commutator = <> );
+CREATE FUNCTION vint4float4ne(vint4, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vint4, rightarg = float4, procedure = vint4float4ne, commutator = = );
+CREATE FUNCTION vint4float4lt(vint4, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vint4, rightarg = float4, procedure = vint4float4lt, commutator = >= );
+CREATE FUNCTION vint4float4le(vint4, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vint4, rightarg = float4, procedure = vint4float4le, commutator = > );
+CREATE FUNCTION vint4float8gt(vint4, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vint4, rightarg = float8, procedure = vint4float8gt, commutator = <= );
+CREATE FUNCTION vint4float8ge(vint4, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vint4, rightarg = float8, procedure = vint4float8ge, commutator = < );
+CREATE FUNCTION vint4float8eq(vint4, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vint4, rightarg = float8, procedure = vint4float8eq, commutator = <> );
+CREATE FUNCTION vint4float8ne(vint4, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vint4, rightarg = float8, procedure = vint4float8ne, commutator = = );
+CREATE FUNCTION vint4float8lt(vint4, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vint4, rightarg = float8, procedure = vint4float8lt, commutator = >= );
+CREATE FUNCTION vint4float8le(vint4, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vint4, rightarg = float8, procedure = vint4float8le, commutator = > );
+
+CREATE FUNCTION vint8vint2gt(vint8, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vint8, rightarg = vint2, procedure = vint8vint2gt, commutator = <= );
+CREATE FUNCTION vint8vint2ge(vint8, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vint8, rightarg = vint2, procedure = vint8vint2ge, commutator = < );
+CREATE FUNCTION vint8vint2eq(vint8, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vint8, rightarg = vint2, procedure = vint8vint2eq, commutator = <> );
+CREATE FUNCTION vint8vint2ne(vint8, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vint8, rightarg = vint2, procedure = vint8vint2ne, commutator = = );
+CREATE FUNCTION vint8vint2lt(vint8, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vint8, rightarg = vint2, procedure = vint8vint2lt, commutator = >= );
+CREATE FUNCTION vint8vint2le(vint8, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vint8, rightarg = vint2, procedure = vint8vint2le, commutator = > );
+CREATE FUNCTION vint8vint4gt(vint8, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vint8, rightarg = vint4, procedure = vint8vint4gt, commutator = <= );
+CREATE FUNCTION vint8vint4ge(vint8, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vint8, rightarg = vint4, procedure = vint8vint4ge, commutator = < );
+CREATE FUNCTION vint8vint4eq(vint8, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vint8, rightarg = vint4, procedure = vint8vint4eq, commutator = <> );
+CREATE FUNCTION vint8vint4ne(vint8, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vint8, rightarg = vint4, procedure = vint8vint4ne, commutator = = );
+CREATE FUNCTION vint8vint4lt(vint8, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vint8, rightarg = vint4, procedure = vint8vint4lt, commutator = >= );
+CREATE FUNCTION vint8vint4le(vint8, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vint8, rightarg = vint4, procedure = vint8vint4le, commutator = > );
+CREATE FUNCTION vint8vint8gt(vint8, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vint8, rightarg = vint8, procedure = vint8vint8gt, commutator = <= );
+CREATE FUNCTION vint8vint8ge(vint8, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vint8, rightarg = vint8, procedure = vint8vint8ge, commutator = < );
+CREATE FUNCTION vint8vint8eq(vint8, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vint8, rightarg = vint8, procedure = vint8vint8eq, commutator = <> );
+CREATE FUNCTION vint8vint8ne(vint8, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vint8, rightarg = vint8, procedure = vint8vint8ne, commutator = = );
+CREATE FUNCTION vint8vint8lt(vint8, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vint8, rightarg = vint8, procedure = vint8vint8lt, commutator = >= );
+CREATE FUNCTION vint8vint8le(vint8, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vint8, rightarg = vint8, procedure = vint8vint8le, commutator = > );
+CREATE FUNCTION vint8vfloat4gt(vint8, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vint8, rightarg = vfloat4, procedure = vint8vfloat4gt, commutator = <= );
+CREATE FUNCTION vint8vfloat4ge(vint8, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vint8, rightarg = vfloat4, procedure = vint8vfloat4ge, commutator = < );
+CREATE FUNCTION vint8vfloat4eq(vint8, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vint8, rightarg = vfloat4, procedure = vint8vfloat4eq, commutator = <> );
+CREATE FUNCTION vint8vfloat4ne(vint8, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vint8, rightarg = vfloat4, procedure = vint8vfloat4ne, commutator = = );
+CREATE FUNCTION vint8vfloat4lt(vint8, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vint8, rightarg = vfloat4, procedure = vint8vfloat4lt, commutator = >= );
+CREATE FUNCTION vint8vfloat4le(vint8, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vint8, rightarg = vfloat4, procedure = vint8vfloat4le, commutator = > );
+CREATE FUNCTION vint8vfloat8gt(vint8, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vint8, rightarg = vfloat8, procedure = vint8vfloat8gt, commutator = <= );
+CREATE FUNCTION vint8vfloat8ge(vint8, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vint8, rightarg = vfloat8, procedure = vint8vfloat8ge, commutator = < );
+CREATE FUNCTION vint8vfloat8eq(vint8, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vint8, rightarg = vfloat8, procedure = vint8vfloat8eq, commutator = <> );
+CREATE FUNCTION vint8vfloat8ne(vint8, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vint8, rightarg = vfloat8, procedure = vint8vfloat8ne, commutator = = );
+CREATE FUNCTION vint8vfloat8lt(vint8, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vint8, rightarg = vfloat8, procedure = vint8vfloat8lt, commutator = >= );
+CREATE FUNCTION vint8vfloat8le(vint8, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vint8, rightarg = vfloat8, procedure = vint8vfloat8le, commutator = > );
+CREATE FUNCTION vint8int2gt(vint8, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vint8, rightarg = int2, procedure = vint8int2gt, commutator = <= );
+CREATE FUNCTION vint8int2ge(vint8, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vint8, rightarg = int2, procedure = vint8int2ge, commutator = < );
+CREATE FUNCTION vint8int2eq(vint8, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vint8, rightarg = int2, procedure = vint8int2eq, commutator = <> );
+CREATE FUNCTION vint8int2ne(vint8, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vint8, rightarg = int2, procedure = vint8int2ne, commutator = = );
+CREATE FUNCTION vint8int2lt(vint8, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vint8, rightarg = int2, procedure = vint8int2lt, commutator = >= );
+CREATE FUNCTION vint8int2le(vint8, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vint8, rightarg = int2, procedure = vint8int2le, commutator = > );
+CREATE FUNCTION vint8int4gt(vint8, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vint8, rightarg = int4, procedure = vint8int4gt, commutator = <= );
+CREATE FUNCTION vint8int4ge(vint8, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vint8, rightarg = int4, procedure = vint8int4ge, commutator = < );
+CREATE FUNCTION vint8int4eq(vint8, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vint8, rightarg = int4, procedure = vint8int4eq, commutator = <> );
+CREATE FUNCTION vint8int4ne(vint8, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vint8, rightarg = int4, procedure = vint8int4ne, commutator = = );
+CREATE FUNCTION vint8int4lt(vint8, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vint8, rightarg = int4, procedure = vint8int4lt, commutator = >= );
+CREATE FUNCTION vint8int4le(vint8, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vint8, rightarg = int4, procedure = vint8int4le, commutator = > );
+CREATE FUNCTION vint8int8gt(vint8, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vint8, rightarg = int8, procedure = vint8int8gt, commutator = <= );
+CREATE FUNCTION vint8int8ge(vint8, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vint8, rightarg = int8, procedure = vint8int8ge, commutator = < );
+CREATE FUNCTION vint8int8eq(vint8, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vint8, rightarg = int8, procedure = vint8int8eq, commutator = <> );
+CREATE FUNCTION vint8int8ne(vint8, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vint8, rightarg = int8, procedure = vint8int8ne, commutator = = );
+CREATE FUNCTION vint8int8lt(vint8, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vint8, rightarg = int8, procedure = vint8int8lt, commutator = >= );
+CREATE FUNCTION vint8int8le(vint8, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vint8, rightarg = int8, procedure = vint8int8le, commutator = > );
+CREATE FUNCTION vint8float4gt(vint8, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vint8, rightarg = float4, procedure = vint8float4gt, commutator = <= );
+CREATE FUNCTION vint8float4ge(vint8, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vint8, rightarg = float4, procedure = vint8float4ge, commutator = < );
+CREATE FUNCTION vint8float4eq(vint8, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vint8, rightarg = float4, procedure = vint8float4eq, commutator = <> );
+CREATE FUNCTION vint8float4ne(vint8, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vint8, rightarg = float4, procedure = vint8float4ne, commutator = = );
+CREATE FUNCTION vint8float4lt(vint8, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vint8, rightarg = float4, procedure = vint8float4lt, commutator = >= );
+CREATE FUNCTION vint8float4le(vint8, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vint8, rightarg = float4, procedure = vint8float4le, commutator = > );
+CREATE FUNCTION vint8float8gt(vint8, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vint8, rightarg = float8, procedure = vint8float8gt, commutator = <= );
+CREATE FUNCTION vint8float8ge(vint8, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vint8, rightarg = float8, procedure = vint8float8ge, commutator = < );
+CREATE FUNCTION vint8float8eq(vint8, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vint8, rightarg = float8, procedure = vint8float8eq, commutator = <> );
+CREATE FUNCTION vint8float8ne(vint8, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vint8, rightarg = float8, procedure = vint8float8ne, commutator = = );
+CREATE FUNCTION vint8float8lt(vint8, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vint8, rightarg = float8, procedure = vint8float8lt, commutator = >= );
+CREATE FUNCTION vint8float8le(vint8, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vint8, rightarg = float8, procedure = vint8float8le, commutator = > );
+
+CREATE FUNCTION vfloat4vint2gt(vfloat4, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vfloat4, rightarg = vint2, procedure = vfloat4vint2gt, commutator = <= );
+CREATE FUNCTION vfloat4vint2ge(vfloat4, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vfloat4, rightarg = vint2, procedure = vfloat4vint2ge, commutator = < );
+CREATE FUNCTION vfloat4vint2eq(vfloat4, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vfloat4, rightarg = vint2, procedure = vfloat4vint2eq, commutator = <> );
+CREATE FUNCTION vfloat4vint2ne(vfloat4, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vfloat4, rightarg = vint2, procedure = vfloat4vint2ne, commutator = = );
+CREATE FUNCTION vfloat4vint2lt(vfloat4, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vfloat4, rightarg = vint2, procedure = vfloat4vint2lt, commutator = >= );
+CREATE FUNCTION vfloat4vint2le(vfloat4, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vfloat4, rightarg = vint2, procedure = vfloat4vint2le, commutator = > );
+CREATE FUNCTION vfloat4vint4gt(vfloat4, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vfloat4, rightarg = vint4, procedure = vfloat4vint4gt, commutator = <= );
+CREATE FUNCTION vfloat4vint4ge(vfloat4, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vfloat4, rightarg = vint4, procedure = vfloat4vint4ge, commutator = < );
+CREATE FUNCTION vfloat4vint4eq(vfloat4, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vfloat4, rightarg = vint4, procedure = vfloat4vint4eq, commutator = <> );
+CREATE FUNCTION vfloat4vint4ne(vfloat4, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vfloat4, rightarg = vint4, procedure = vfloat4vint4ne, commutator = = );
+CREATE FUNCTION vfloat4vint4lt(vfloat4, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vfloat4, rightarg = vint4, procedure = vfloat4vint4lt, commutator = >= );
+CREATE FUNCTION vfloat4vint4le(vfloat4, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vfloat4, rightarg = vint4, procedure = vfloat4vint4le, commutator = > );
+CREATE FUNCTION vfloat4vint8gt(vfloat4, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vfloat4, rightarg = vint8, procedure = vfloat4vint8gt, commutator = <= );
+CREATE FUNCTION vfloat4vint8ge(vfloat4, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vfloat4, rightarg = vint8, procedure = vfloat4vint8ge, commutator = < );
+CREATE FUNCTION vfloat4vint8eq(vfloat4, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vfloat4, rightarg = vint8, procedure = vfloat4vint8eq, commutator = <> );
+CREATE FUNCTION vfloat4vint8ne(vfloat4, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vfloat4, rightarg = vint8, procedure = vfloat4vint8ne, commutator = = );
+CREATE FUNCTION vfloat4vint8lt(vfloat4, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vfloat4, rightarg = vint8, procedure = vfloat4vint8lt, commutator = >= );
+CREATE FUNCTION vfloat4vint8le(vfloat4, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vfloat4, rightarg = vint8, procedure = vfloat4vint8le, commutator = > );
+CREATE FUNCTION vfloat4vfloat4gt(vfloat4, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vfloat4, rightarg = vfloat4, procedure = vfloat4vfloat4gt, commutator = <= );
+CREATE FUNCTION vfloat4vfloat4ge(vfloat4, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vfloat4, rightarg = vfloat4, procedure = vfloat4vfloat4ge, commutator = < );
+CREATE FUNCTION vfloat4vfloat4eq(vfloat4, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vfloat4, rightarg = vfloat4, procedure = vfloat4vfloat4eq, commutator = <> );
+CREATE FUNCTION vfloat4vfloat4ne(vfloat4, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vfloat4, rightarg = vfloat4, procedure = vfloat4vfloat4ne, commutator = = );
+CREATE FUNCTION vfloat4vfloat4lt(vfloat4, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vfloat4, rightarg = vfloat4, procedure = vfloat4vfloat4lt, commutator = >= );
+CREATE FUNCTION vfloat4vfloat4le(vfloat4, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vfloat4, rightarg = vfloat4, procedure = vfloat4vfloat4le, commutator = > );
+CREATE FUNCTION vfloat4vfloat8gt(vfloat4, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vfloat4, rightarg = vfloat8, procedure = vfloat4vfloat8gt, commutator = <= );
+CREATE FUNCTION vfloat4vfloat8ge(vfloat4, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vfloat4, rightarg = vfloat8, procedure = vfloat4vfloat8ge, commutator = < );
+CREATE FUNCTION vfloat4vfloat8eq(vfloat4, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vfloat4, rightarg = vfloat8, procedure = vfloat4vfloat8eq, commutator = <> );
+CREATE FUNCTION vfloat4vfloat8ne(vfloat4, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vfloat4, rightarg = vfloat8, procedure = vfloat4vfloat8ne, commutator = = );
+CREATE FUNCTION vfloat4vfloat8lt(vfloat4, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vfloat4, rightarg = vfloat8, procedure = vfloat4vfloat8lt, commutator = >= );
+CREATE FUNCTION vfloat4vfloat8le(vfloat4, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vfloat4, rightarg = vfloat8, procedure = vfloat4vfloat8le, commutator = > );
+CREATE FUNCTION vfloat4int2gt(vfloat4, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vfloat4, rightarg = int2, procedure = vfloat4int2gt, commutator = <= );
+CREATE FUNCTION vfloat4int2ge(vfloat4, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vfloat4, rightarg = int2, procedure = vfloat4int2ge, commutator = < );
+CREATE FUNCTION vfloat4int2eq(vfloat4, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vfloat4, rightarg = int2, procedure = vfloat4int2eq, commutator = <> );
+CREATE FUNCTION vfloat4int2ne(vfloat4, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vfloat4, rightarg = int2, procedure = vfloat4int2ne, commutator = = );
+CREATE FUNCTION vfloat4int2lt(vfloat4, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vfloat4, rightarg = int2, procedure = vfloat4int2lt, commutator = >= );
+CREATE FUNCTION vfloat4int2le(vfloat4, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vfloat4, rightarg = int2, procedure = vfloat4int2le, commutator = > );
+CREATE FUNCTION vfloat4int4gt(vfloat4, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vfloat4, rightarg = int4, procedure = vfloat4int4gt, commutator = <= );
+CREATE FUNCTION vfloat4int4ge(vfloat4, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vfloat4, rightarg = int4, procedure = vfloat4int4ge, commutator = < );
+CREATE FUNCTION vfloat4int4eq(vfloat4, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vfloat4, rightarg = int4, procedure = vfloat4int4eq, commutator = <> );
+CREATE FUNCTION vfloat4int4ne(vfloat4, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vfloat4, rightarg = int4, procedure = vfloat4int4ne, commutator = = );
+CREATE FUNCTION vfloat4int4lt(vfloat4, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vfloat4, rightarg = int4, procedure = vfloat4int4lt, commutator = >= );
+CREATE FUNCTION vfloat4int4le(vfloat4, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vfloat4, rightarg = int4, procedure = vfloat4int4le, commutator = > );
+CREATE FUNCTION vfloat4int8gt(vfloat4, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vfloat4, rightarg = int8, procedure = vfloat4int8gt, commutator = <= );
+CREATE FUNCTION vfloat4int8ge(vfloat4, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vfloat4, rightarg = int8, procedure = vfloat4int8ge, commutator = < );
+CREATE FUNCTION vfloat4int8eq(vfloat4, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vfloat4, rightarg = int8, procedure = vfloat4int8eq, commutator = <> );
+CREATE FUNCTION vfloat4int8ne(vfloat4, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vfloat4, rightarg = int8, procedure = vfloat4int8ne, commutator = = );
+CREATE FUNCTION vfloat4int8lt(vfloat4, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vfloat4, rightarg = int8, procedure = vfloat4int8lt, commutator = >= );
+CREATE FUNCTION vfloat4int8le(vfloat4, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vfloat4, rightarg = int8, procedure = vfloat4int8le, commutator = > );
+CREATE FUNCTION vfloat4float4gt(vfloat4, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vfloat4, rightarg = float4, procedure = vfloat4float4gt, commutator = <= );
+CREATE FUNCTION vfloat4float4ge(vfloat4, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vfloat4, rightarg = float4, procedure = vfloat4float4ge, commutator = < );
+CREATE FUNCTION vfloat4float4eq(vfloat4, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vfloat4, rightarg = float4, procedure = vfloat4float4eq, commutator = <> );
+CREATE FUNCTION vfloat4float4ne(vfloat4, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vfloat4, rightarg = float4, procedure = vfloat4float4ne, commutator = = );
+CREATE FUNCTION vfloat4float4lt(vfloat4, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vfloat4, rightarg = float4, procedure = vfloat4float4lt, commutator = >= );
+CREATE FUNCTION vfloat4float4le(vfloat4, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vfloat4, rightarg = float4, procedure = vfloat4float4le, commutator = > );
+CREATE FUNCTION vfloat4float8gt(vfloat4, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vfloat4, rightarg = float8, procedure = vfloat4float8gt, commutator = <= );
+CREATE FUNCTION vfloat4float8ge(vfloat4, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vfloat4, rightarg = float8, procedure = vfloat4float8ge, commutator = < );
+CREATE FUNCTION vfloat4float8eq(vfloat4, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vfloat4, rightarg = float8, procedure = vfloat4float8eq, commutator = <> );
+CREATE FUNCTION vfloat4float8ne(vfloat4, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vfloat4, rightarg = float8, procedure = vfloat4float8ne, commutator = = );
+CREATE FUNCTION vfloat4float8lt(vfloat4, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vfloat4, rightarg = float8, procedure = vfloat4float8lt, commutator = >= );
+CREATE FUNCTION vfloat4float8le(vfloat4, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vfloat4, rightarg = float8, procedure = vfloat4float8le, commutator = > );
+
+CREATE FUNCTION vfloat8vint2gt(vfloat8, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vfloat8, rightarg = vint2, procedure = vfloat8vint2gt, commutator = <= );
+CREATE FUNCTION vfloat8vint2ge(vfloat8, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vfloat8, rightarg = vint2, procedure = vfloat8vint2ge, commutator = < );
+CREATE FUNCTION vfloat8vint2eq(vfloat8, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vfloat8, rightarg = vint2, procedure = vfloat8vint2eq, commutator = <> );
+CREATE FUNCTION vfloat8vint2ne(vfloat8, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vfloat8, rightarg = vint2, procedure = vfloat8vint2ne, commutator = = );
+CREATE FUNCTION vfloat8vint2lt(vfloat8, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vfloat8, rightarg = vint2, procedure = vfloat8vint2lt, commutator = >= );
+CREATE FUNCTION vfloat8vint2le(vfloat8, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vfloat8, rightarg = vint2, procedure = vfloat8vint2le, commutator = > );
+CREATE FUNCTION vfloat8vint4gt(vfloat8, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vfloat8, rightarg = vint4, procedure = vfloat8vint4gt, commutator = <= );
+CREATE FUNCTION vfloat8vint4ge(vfloat8, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vfloat8, rightarg = vint4, procedure = vfloat8vint4ge, commutator = < );
+CREATE FUNCTION vfloat8vint4eq(vfloat8, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vfloat8, rightarg = vint4, procedure = vfloat8vint4eq, commutator = <> );
+CREATE FUNCTION vfloat8vint4ne(vfloat8, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vfloat8, rightarg = vint4, procedure = vfloat8vint4ne, commutator = = );
+CREATE FUNCTION vfloat8vint4lt(vfloat8, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vfloat8, rightarg = vint4, procedure = vfloat8vint4lt, commutator = >= );
+CREATE FUNCTION vfloat8vint4le(vfloat8, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vfloat8, rightarg = vint4, procedure = vfloat8vint4le, commutator = > );
+CREATE FUNCTION vfloat8vint8gt(vfloat8, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vfloat8, rightarg = vint8, procedure = vfloat8vint8gt, commutator = <= );
+CREATE FUNCTION vfloat8vint8ge(vfloat8, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vfloat8, rightarg = vint8, procedure = vfloat8vint8ge, commutator = < );
+CREATE FUNCTION vfloat8vint8eq(vfloat8, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vfloat8, rightarg = vint8, procedure = vfloat8vint8eq, commutator = <> );
+CREATE FUNCTION vfloat8vint8ne(vfloat8, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vfloat8, rightarg = vint8, procedure = vfloat8vint8ne, commutator = = );
+CREATE FUNCTION vfloat8vint8lt(vfloat8, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vfloat8, rightarg = vint8, procedure = vfloat8vint8lt, commutator = >= );
+CREATE FUNCTION vfloat8vint8le(vfloat8, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vfloat8, rightarg = vint8, procedure = vfloat8vint8le, commutator = > );
+CREATE FUNCTION vfloat8vfloat4gt(vfloat8, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vfloat8, rightarg = vfloat4, procedure = vfloat8vfloat4gt, commutator = <= );
+CREATE FUNCTION vfloat8vfloat4ge(vfloat8, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vfloat8, rightarg = vfloat4, procedure = vfloat8vfloat4ge, commutator = < );
+CREATE FUNCTION vfloat8vfloat4eq(vfloat8, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vfloat8, rightarg = vfloat4, procedure = vfloat8vfloat4eq, commutator = <> );
+CREATE FUNCTION vfloat8vfloat4ne(vfloat8, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vfloat8, rightarg = vfloat4, procedure = vfloat8vfloat4ne, commutator = = );
+CREATE FUNCTION vfloat8vfloat4lt(vfloat8, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vfloat8, rightarg = vfloat4, procedure = vfloat8vfloat4lt, commutator = >= );
+CREATE FUNCTION vfloat8vfloat4le(vfloat8, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vfloat8, rightarg = vfloat4, procedure = vfloat8vfloat4le, commutator = > );
+CREATE FUNCTION vfloat8vfloat8gt(vfloat8, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vfloat8, rightarg = vfloat8, procedure = vfloat8vfloat8gt, commutator = <= );
+CREATE FUNCTION vfloat8vfloat8ge(vfloat8, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vfloat8, rightarg = vfloat8, procedure = vfloat8vfloat8ge, commutator = < );
+CREATE FUNCTION vfloat8vfloat8eq(vfloat8, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vfloat8, rightarg = vfloat8, procedure = vfloat8vfloat8eq, commutator = <> );
+CREATE FUNCTION vfloat8vfloat8ne(vfloat8, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vfloat8, rightarg = vfloat8, procedure = vfloat8vfloat8ne, commutator = = );
+CREATE FUNCTION vfloat8vfloat8lt(vfloat8, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vfloat8, rightarg = vfloat8, procedure = vfloat8vfloat8lt, commutator = >= );
+CREATE FUNCTION vfloat8vfloat8le(vfloat8, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vfloat8, rightarg = vfloat8, procedure = vfloat8vfloat8le, commutator = > );
+CREATE FUNCTION vfloat8int2gt(vfloat8, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vfloat8, rightarg = int2, procedure = vfloat8int2gt, commutator = <= );
+CREATE FUNCTION vfloat8int2ge(vfloat8, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vfloat8, rightarg = int2, procedure = vfloat8int2ge, commutator = < );
+CREATE FUNCTION vfloat8int2eq(vfloat8, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vfloat8, rightarg = int2, procedure = vfloat8int2eq, commutator = <> );
+CREATE FUNCTION vfloat8int2ne(vfloat8, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vfloat8, rightarg = int2, procedure = vfloat8int2ne, commutator = = );
+CREATE FUNCTION vfloat8int2lt(vfloat8, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vfloat8, rightarg = int2, procedure = vfloat8int2lt, commutator = >= );
+CREATE FUNCTION vfloat8int2le(vfloat8, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vfloat8, rightarg = int2, procedure = vfloat8int2le, commutator = > );
+CREATE FUNCTION vfloat8int4gt(vfloat8, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vfloat8, rightarg = int4, procedure = vfloat8int4gt, commutator = <= );
+CREATE FUNCTION vfloat8int4ge(vfloat8, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vfloat8, rightarg = int4, procedure = vfloat8int4ge, commutator = < );
+CREATE FUNCTION vfloat8int4eq(vfloat8, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vfloat8, rightarg = int4, procedure = vfloat8int4eq, commutator = <> );
+CREATE FUNCTION vfloat8int4ne(vfloat8, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vfloat8, rightarg = int4, procedure = vfloat8int4ne, commutator = = );
+CREATE FUNCTION vfloat8int4lt(vfloat8, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vfloat8, rightarg = int4, procedure = vfloat8int4lt, commutator = >= );
+CREATE FUNCTION vfloat8int4le(vfloat8, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vfloat8, rightarg = int4, procedure = vfloat8int4le, commutator = > );
+CREATE FUNCTION vfloat8int8gt(vfloat8, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vfloat8, rightarg = int8, procedure = vfloat8int8gt, commutator = <= );
+CREATE FUNCTION vfloat8int8ge(vfloat8, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vfloat8, rightarg = int8, procedure = vfloat8int8ge, commutator = < );
+CREATE FUNCTION vfloat8int8eq(vfloat8, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vfloat8, rightarg = int8, procedure = vfloat8int8eq, commutator = <> );
+CREATE FUNCTION vfloat8int8ne(vfloat8, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vfloat8, rightarg = int8, procedure = vfloat8int8ne, commutator = = );
+CREATE FUNCTION vfloat8int8lt(vfloat8, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vfloat8, rightarg = int8, procedure = vfloat8int8lt, commutator = >= );
+CREATE FUNCTION vfloat8int8le(vfloat8, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vfloat8, rightarg = int8, procedure = vfloat8int8le, commutator = > );
+CREATE FUNCTION vfloat8float4gt(vfloat8, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vfloat8, rightarg = float4, procedure = vfloat8float4gt, commutator = <= );
+CREATE FUNCTION vfloat8float4ge(vfloat8, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vfloat8, rightarg = float4, procedure = vfloat8float4ge, commutator = < );
+CREATE FUNCTION vfloat8float4eq(vfloat8, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vfloat8, rightarg = float4, procedure = vfloat8float4eq, commutator = <> );
+CREATE FUNCTION vfloat8float4ne(vfloat8, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vfloat8, rightarg = float4, procedure = vfloat8float4ne, commutator = = );
+CREATE FUNCTION vfloat8float4lt(vfloat8, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vfloat8, rightarg = float4, procedure = vfloat8float4lt, commutator = >= );
+CREATE FUNCTION vfloat8float4le(vfloat8, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vfloat8, rightarg = float4, procedure = vfloat8float4le, commutator = > );
+CREATE FUNCTION vfloat8float8gt(vfloat8, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR > ( leftarg = vfloat8, rightarg = float8, procedure = vfloat8float8gt, commutator = <= );
+CREATE FUNCTION vfloat8float8ge(vfloat8, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR >= ( leftarg = vfloat8, rightarg = float8, procedure = vfloat8float8ge, commutator = < );
+CREATE FUNCTION vfloat8float8eq(vfloat8, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR = ( leftarg = vfloat8, rightarg = float8, procedure = vfloat8float8eq, commutator = <> );
+CREATE FUNCTION vfloat8float8ne(vfloat8, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <> ( leftarg = vfloat8, rightarg = float8, procedure = vfloat8float8ne, commutator = = );
+CREATE FUNCTION vfloat8float8lt(vfloat8, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR < ( leftarg = vfloat8, rightarg = float8, procedure = vfloat8float8lt, commutator = >= );
+CREATE FUNCTION vfloat8float8le(vfloat8, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR <= ( leftarg = vfloat8, rightarg = float8, procedure = vfloat8float8le, commutator = > );
+
+
+CREATE FUNCTION vint2vint2pl(vint2, vint2) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR + ( leftarg = vint2, rightarg = vint2, procedure = vint2vint2pl, commutator = - );
+CREATE FUNCTION vint2vint2mi(vint2, vint2) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR - ( leftarg = vint2, rightarg = vint2, procedure = vint2vint2mi, commutator = + );
+CREATE FUNCTION vint2vint2mul(vint2, vint2) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR * ( leftarg = vint2, rightarg = vint2, procedure = vint2vint2mul, commutator = / );
+CREATE FUNCTION vint2vint2div(vint2, vint2) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR / ( leftarg = vint2, rightarg = vint2, procedure = vint2vint2div, commutator = * );
+
+CREATE FUNCTION vint4vint4pl(vint4, vint4) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR + ( leftarg = vint4, rightarg = vint4, procedure = vint4vint4pl, commutator = - );
+CREATE FUNCTION vint4vint4mi(vint4, vint4) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR - ( leftarg = vint4, rightarg = vint4, procedure = vint4vint4mi, commutator = + );
+CREATE FUNCTION vint4vint4mul(vint4, vint4) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR * ( leftarg = vint4, rightarg = vint4, procedure = vint4vint4mul, commutator = / );
+CREATE FUNCTION vint4vint4div(vint4, vint4) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR / ( leftarg = vint4, rightarg = vint4, procedure = vint4vint4div, commutator = * );
+
+CREATE FUNCTION vint8vint8pl(vint8, vint8) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR + ( leftarg = vint8, rightarg = vint8, procedure = vint8vint8pl, commutator = - );
+CREATE FUNCTION vint8vint8mi(vint8, vint8) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR - ( leftarg = vint8, rightarg = vint8, procedure = vint8vint8mi, commutator = + );
+CREATE FUNCTION vint8vint8mul(vint8, vint8) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR * ( leftarg = vint8, rightarg = vint8, procedure = vint8vint8mul, commutator = / );
+CREATE FUNCTION vint8vint8div(vint8, vint8) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR / ( leftarg = vint8, rightarg = vint8, procedure = vint8vint8div, commutator = * );
+
+
+CREATE FUNCTION vfloat4vfloat4pl(vfloat4, vfloat4) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR + ( leftarg = vfloat4, rightarg = vfloat4, procedure = vfloat4vfloat4pl, commutator = - );
+CREATE FUNCTION vfloat4vfloat4mi(vfloat4, vfloat4) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR - ( leftarg = vfloat4, rightarg = vfloat4, procedure = vfloat4vfloat4mi, commutator = + );
+CREATE FUNCTION vfloat4vfloat4mul(vfloat4, vfloat4) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR * ( leftarg = vfloat4, rightarg = vfloat4, procedure = vfloat4vfloat4mul, commutator = / );
+CREATE FUNCTION vfloat4vfloat4div(vfloat4, vfloat4) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR / ( leftarg = vfloat4, rightarg = vfloat4, procedure = vfloat4vfloat4div, commutator = * );
+
+
+
+CREATE FUNCTION vfloat8vfloat8pl(vfloat8, vfloat8) RETURNS vfloat8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR + ( leftarg = vfloat8, rightarg = vfloat8, procedure = vfloat8vfloat8pl, commutator = - );
+CREATE FUNCTION vfloat8vfloat8mi(vfloat8, vfloat8) RETURNS vfloat8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR - ( leftarg = vfloat8, rightarg = vfloat8, procedure = vfloat8vfloat8mi, commutator = + );
+CREATE FUNCTION vfloat8vfloat8mul(vfloat8, vfloat8) RETURNS vfloat8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR * ( leftarg = vfloat8, rightarg = vfloat8, procedure = vfloat8vfloat8mul, commutator = / );
+CREATE FUNCTION vfloat8vfloat8div(vfloat8, vfloat8) RETURNS vfloat8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR / ( leftarg = vfloat8, rightarg = vfloat8, procedure = vfloat8vfloat8div, commutator = * );
+
+
+
+
+
+CREATE FUNCTION vint2int2pl(vint2, int2) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR + ( leftarg = vint2, rightarg = int2, procedure = vint2int2pl, commutator = - );
+CREATE FUNCTION vint2int2mi(vint2, int2) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR - ( leftarg = vint2, rightarg = int2, procedure = vint2int2mi, commutator = + );
+CREATE FUNCTION vint2int2mul(vint2, int2) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR * ( leftarg = vint2, rightarg = int2, procedure = vint2int2mul, commutator = / );
+CREATE FUNCTION vint2int2div(vint2, int2) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR / ( leftarg = vint2, rightarg = int2, procedure = vint2int2div, commutator = * );
+CREATE FUNCTION vint2int4pl(vint2, int4) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR + ( leftarg = vint2, rightarg = int4, procedure = vint2int4pl, commutator = - );
+CREATE FUNCTION vint2int4mi(vint2, int4) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR - ( leftarg = vint2, rightarg = int4, procedure = vint2int4mi, commutator = + );
+CREATE FUNCTION vint2int4mul(vint2, int4) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR * ( leftarg = vint2, rightarg = int4, procedure = vint2int4mul, commutator = / );
+CREATE FUNCTION vint2int4div(vint2, int4) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR / ( leftarg = vint2, rightarg = int4, procedure = vint2int4div, commutator = * );
+CREATE FUNCTION vint2int8pl(vint2, int8) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR + ( leftarg = vint2, rightarg = int8, procedure = vint2int8pl, commutator = - );
+CREATE FUNCTION vint2int8mi(vint2, int8) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR - ( leftarg = vint2, rightarg = int8, procedure = vint2int8mi, commutator = + );
+CREATE FUNCTION vint2int8mul(vint2, int8) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR * ( leftarg = vint2, rightarg = int8, procedure = vint2int8mul, commutator = / );
+CREATE FUNCTION vint2int8div(vint2, int8) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR / ( leftarg = vint2, rightarg = int8, procedure = vint2int8div, commutator = * );
+CREATE FUNCTION vint2float4pl(vint2, float4) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR + ( leftarg = vint2, rightarg = float4, procedure = vint2float4pl, commutator = - );
+CREATE FUNCTION vint2float4mi(vint2, float4) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR - ( leftarg = vint2, rightarg = float4, procedure = vint2float4mi, commutator = + );
+CREATE FUNCTION vint2float4mul(vint2, float4) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR * ( leftarg = vint2, rightarg = float4, procedure = vint2float4mul, commutator = / );
+CREATE FUNCTION vint2float4div(vint2, float4) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR / ( leftarg = vint2, rightarg = float4, procedure = vint2float4div, commutator = * );
+CREATE FUNCTION vint2float8pl(vint2, float8) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR + ( leftarg = vint2, rightarg = float8, procedure = vint2float8pl, commutator = - );
+CREATE FUNCTION vint2float8mi(vint2, float8) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR - ( leftarg = vint2, rightarg = float8, procedure = vint2float8mi, commutator = + );
+CREATE FUNCTION vint2float8mul(vint2, float8) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR * ( leftarg = vint2, rightarg = float8, procedure = vint2float8mul, commutator = / );
+CREATE FUNCTION vint2float8div(vint2, float8) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR / ( leftarg = vint2, rightarg = float8, procedure = vint2float8div, commutator = * );
+
+CREATE FUNCTION vint4int2pl(vint4, int2) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR + ( leftarg = vint4, rightarg = int2, procedure = vint4int2pl, commutator = - );
+CREATE FUNCTION vint4int2mi(vint4, int2) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR - ( leftarg = vint4, rightarg = int2, procedure = vint4int2mi, commutator = + );
+CREATE FUNCTION vint4int2mul(vint4, int2) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR * ( leftarg = vint4, rightarg = int2, procedure = vint4int2mul, commutator = / );
+CREATE FUNCTION vint4int2div(vint4, int2) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR / ( leftarg = vint4, rightarg = int2, procedure = vint4int2div, commutator = * );
+CREATE FUNCTION vint4int4pl(vint4, int4) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR + ( leftarg = vint4, rightarg = int4, procedure = vint4int4pl, commutator = - );
+CREATE FUNCTION vint4int4mi(vint4, int4) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR - ( leftarg = vint4, rightarg = int4, procedure = vint4int4mi, commutator = + );
+CREATE FUNCTION vint4int4mul(vint4, int4) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR * ( leftarg = vint4, rightarg = int4, procedure = vint4int4mul, commutator = / );
+CREATE FUNCTION vint4int4div(vint4, int4) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR / ( leftarg = vint4, rightarg = int4, procedure = vint4int4div, commutator = * );
+CREATE FUNCTION vint4int8pl(vint4, int8) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR + ( leftarg = vint4, rightarg = int8, procedure = vint4int8pl, commutator = - );
+CREATE FUNCTION vint4int8mi(vint4, int8) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR - ( leftarg = vint4, rightarg = int8, procedure = vint4int8mi, commutator = + );
+CREATE FUNCTION vint4int8mul(vint4, int8) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR * ( leftarg = vint4, rightarg = int8, procedure = vint4int8mul, commutator = / );
+CREATE FUNCTION vint4int8div(vint4, int8) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR / ( leftarg = vint4, rightarg = int8, procedure = vint4int8div, commutator = * );
+CREATE FUNCTION vint4float4pl(vint4, float4) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR + ( leftarg = vint4, rightarg = float4, procedure = vint4float4pl, commutator = - );
+CREATE FUNCTION vint4float4mi(vint4, float4) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR - ( leftarg = vint4, rightarg = float4, procedure = vint4float4mi, commutator = + );
+CREATE FUNCTION vint4float4mul(vint4, float4) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR * ( leftarg = vint4, rightarg = float4, procedure = vint4float4mul, commutator = / );
+CREATE FUNCTION vint4float4div(vint4, float4) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR / ( leftarg = vint4, rightarg = float4, procedure = vint4float4div, commutator = * );
+CREATE FUNCTION vint4float8pl(vint4, float8) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR + ( leftarg = vint4, rightarg = float8, procedure = vint4float8pl, commutator = - );
+CREATE FUNCTION vint4float8mi(vint4, float8) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR - ( leftarg = vint4, rightarg = float8, procedure = vint4float8mi, commutator = + );
+CREATE FUNCTION vint4float8mul(vint4, float8) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR * ( leftarg = vint4, rightarg = float8, procedure = vint4float8mul, commutator = / );
+CREATE FUNCTION vint4float8div(vint4, float8) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR / ( leftarg = vint4, rightarg = float8, procedure = vint4float8div, commutator = * );
+
+CREATE FUNCTION vint8int2pl(vint8, int2) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR + ( leftarg = vint8, rightarg = int2, procedure = vint8int2pl, commutator = - );
+CREATE FUNCTION vint8int2mi(vint8, int2) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR - ( leftarg = vint8, rightarg = int2, procedure = vint8int2mi, commutator = + );
+CREATE FUNCTION vint8int2mul(vint8, int2) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR * ( leftarg = vint8, rightarg = int2, procedure = vint8int2mul, commutator = / );
+CREATE FUNCTION vint8int2div(vint8, int2) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR / ( leftarg = vint8, rightarg = int2, procedure = vint8int2div, commutator = * );
+CREATE FUNCTION vint8int4pl(vint8, int4) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR + ( leftarg = vint8, rightarg = int4, procedure = vint8int4pl, commutator = - );
+CREATE FUNCTION vint8int4mi(vint8, int4) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR - ( leftarg = vint8, rightarg = int4, procedure = vint8int4mi, commutator = + );
+CREATE FUNCTION vint8int4mul(vint8, int4) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR * ( leftarg = vint8, rightarg = int4, procedure = vint8int4mul, commutator = / );
+CREATE FUNCTION vint8int4div(vint8, int4) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR / ( leftarg = vint8, rightarg = int4, procedure = vint8int4div, commutator = * );
+CREATE FUNCTION vint8int8pl(vint8, int8) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR + ( leftarg = vint8, rightarg = int8, procedure = vint8int8pl, commutator = - );
+CREATE FUNCTION vint8int8mi(vint8, int8) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR - ( leftarg = vint8, rightarg = int8, procedure = vint8int8mi, commutator = + );
+CREATE FUNCTION vint8int8mul(vint8, int8) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR * ( leftarg = vint8, rightarg = int8, procedure = vint8int8mul, commutator = / );
+CREATE FUNCTION vint8int8div(vint8, int8) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR / ( leftarg = vint8, rightarg = int8, procedure = vint8int8div, commutator = * );
+CREATE FUNCTION vint8float4pl(vint8, float4) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR + ( leftarg = vint8, rightarg = float4, procedure = vint8float4pl, commutator = - );
+CREATE FUNCTION vint8float4mi(vint8, float4) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR - ( leftarg = vint8, rightarg = float4, procedure = vint8float4mi, commutator = + );
+CREATE FUNCTION vint8float4mul(vint8, float4) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR * ( leftarg = vint8, rightarg = float4, procedure = vint8float4mul, commutator = / );
+CREATE FUNCTION vint8float4div(vint8, float4) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR / ( leftarg = vint8, rightarg = float4, procedure = vint8float4div, commutator = * );
+CREATE FUNCTION vint8float8pl(vint8, float8) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR + ( leftarg = vint8, rightarg = float8, procedure = vint8float8pl, commutator = - );
+CREATE FUNCTION vint8float8mi(vint8, float8) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR - ( leftarg = vint8, rightarg = float8, procedure = vint8float8mi, commutator = + );
+CREATE FUNCTION vint8float8mul(vint8, float8) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR * ( leftarg = vint8, rightarg = float8, procedure = vint8float8mul, commutator = / );
+CREATE FUNCTION vint8float8div(vint8, float8) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR / ( leftarg = vint8, rightarg = float8, procedure = vint8float8div, commutator = * );
+
+
+
+CREATE FUNCTION vfloat4int2pl(vfloat4, int2) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR + ( leftarg = vfloat4, rightarg = int2, procedure = vfloat4int2pl, commutator = - );
+CREATE FUNCTION vfloat4int2mi(vfloat4, int2) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR - ( leftarg = vfloat4, rightarg = int2, procedure = vfloat4int2mi, commutator = + );
+CREATE FUNCTION vfloat4int2mul(vfloat4, int2) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR * ( leftarg = vfloat4, rightarg = int2, procedure = vfloat4int2mul, commutator = / );
+CREATE FUNCTION vfloat4int2div(vfloat4, int2) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR / ( leftarg = vfloat4, rightarg = int2, procedure = vfloat4int2div, commutator = * );
+CREATE FUNCTION vfloat4int4pl(vfloat4, int4) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR + ( leftarg = vfloat4, rightarg = int4, procedure = vfloat4int4pl, commutator = - );
+CREATE FUNCTION vfloat4int4mi(vfloat4, int4) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR - ( leftarg = vfloat4, rightarg = int4, procedure = vfloat4int4mi, commutator = + );
+CREATE FUNCTION vfloat4int4mul(vfloat4, int4) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR * ( leftarg = vfloat4, rightarg = int4, procedure = vfloat4int4mul, commutator = / );
+CREATE FUNCTION vfloat4int4div(vfloat4, int4) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR / ( leftarg = vfloat4, rightarg = int4, procedure = vfloat4int4div, commutator = * );
+CREATE FUNCTION vfloat4int8pl(vfloat4, int8) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR + ( leftarg = vfloat4, rightarg = int8, procedure = vfloat4int8pl, commutator = - );
+CREATE FUNCTION vfloat4int8mi(vfloat4, int8) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR - ( leftarg = vfloat4, rightarg = int8, procedure = vfloat4int8mi, commutator = + );
+CREATE FUNCTION vfloat4int8mul(vfloat4, int8) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR * ( leftarg = vfloat4, rightarg = int8, procedure = vfloat4int8mul, commutator = / );
+CREATE FUNCTION vfloat4int8div(vfloat4, int8) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR / ( leftarg = vfloat4, rightarg = int8, procedure = vfloat4int8div, commutator = * );
+CREATE FUNCTION vfloat4float4pl(vfloat4, float4) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR + ( leftarg = vfloat4, rightarg = float4, procedure = vfloat4float4pl, commutator = - );
+CREATE FUNCTION vfloat4float4mi(vfloat4, float4) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR - ( leftarg = vfloat4, rightarg = float4, procedure = vfloat4float4mi, commutator = + );
+CREATE FUNCTION vfloat4float4mul(vfloat4, float4) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR * ( leftarg = vfloat4, rightarg = float4, procedure = vfloat4float4mul, commutator = / );
+CREATE FUNCTION vfloat4float4div(vfloat4, float4) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR / ( leftarg = vfloat4, rightarg = float4, procedure = vfloat4float4div, commutator = * );
+CREATE FUNCTION vfloat4float8pl(vfloat4, float8) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR + ( leftarg = vfloat4, rightarg = float8, procedure = vfloat4float8pl, commutator = - );
+CREATE FUNCTION vfloat4float8mi(vfloat4, float8) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR - ( leftarg = vfloat4, rightarg = float8, procedure = vfloat4float8mi, commutator = + );
+CREATE FUNCTION vfloat4float8mul(vfloat4, float8) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR * ( leftarg = vfloat4, rightarg = float8, procedure = vfloat4float8mul, commutator = / );
+CREATE FUNCTION vfloat4float8div(vfloat4, float8) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR / ( leftarg = vfloat4, rightarg = float8, procedure = vfloat4float8div, commutator = * );
+
+
+
+
+CREATE FUNCTION vfloat8int2pl(vfloat8, int2) RETURNS vfloat8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR + ( leftarg = vfloat8, rightarg = int2, procedure = vfloat8int2pl, commutator = - );
+CREATE FUNCTION vfloat8int2mi(vfloat8, int2) RETURNS vfloat8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR - ( leftarg = vfloat8, rightarg = int2, procedure = vfloat8int2mi, commutator = + );
+CREATE FUNCTION vfloat8int2mul(vfloat8, int2) RETURNS vfloat8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR * ( leftarg = vfloat8, rightarg = int2, procedure = vfloat8int2mul, commutator = / );
+CREATE FUNCTION vfloat8int2div(vfloat8, int2) RETURNS vfloat8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR / ( leftarg = vfloat8, rightarg = int2, procedure = vfloat8int2div, commutator = * );
+CREATE FUNCTION vfloat8int4pl(vfloat8, int4) RETURNS vfloat8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE OPERATOR + ( leftarg = vfloat8, rightarg
<TRUNCATED>
[5/9] incubator-hawq git commit: HAWQ-1612. Implement vectorized
aggregate functions, such as avg/sum/count.
Posted by rl...@apache.org.
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/ce2814d4/contrib/vexecutor/vtype.c
----------------------------------------------------------------------
diff --git a/contrib/vexecutor/vtype.c b/contrib/vexecutor/vtype.c
index 89c6556..8b7c898 100644
--- a/contrib/vexecutor/vtype.c
+++ b/contrib/vexecutor/vtype.c
@@ -181,6 +181,34 @@ v##type##const_type##opstr(PG_FUNCTION_ARGS) \
}
/*
+ * Operator function for the abstract data types, this MACRO is used for the
+ * Consts OP V-types.
+ * e.g. extern Datum int2vint2pl(PG_FUNCTION_ARGS);
+ */
+#define __FUNCTION_OP_LCONST(type, XTYPE, const_type, CONST_ARG_MACRO, opsym, opstr) \
+PG_FUNCTION_INFO_V1(const_type##v##type##opstr); \
+Datum \
+const_type##v##type##opstr(PG_FUNCTION_ARGS) \
+{ \
+ int size = 0; \
+ int i = 0; \
+ const_type arg1 = CONST_ARG_MACRO(0); \
+ v##type *arg2 = PG_GETARG_POINTER(1); \
+ v##type *res = buildv##type(BATCHSIZE, NULL); \
+ size = arg2->dim;\
+ while(i < size) \
+ { \
+ res->isnull[i] = arg2->isnull[i]; \
+ if(!res->isnull[i]) \
+ res->values[i] = XTYPE##GetDatum(((type)arg1) opsym (DatumGet##XTYPE(arg2->values[i]))); \
+ i ++ ;\
+ } \
+ res->dim = arg2->dim; \
+ PG_RETURN_POINTER(res); \
+}
+
+
+/*
* Comparision function for the abstract data types, this MACRO is used for the
* V-types OP V-types.
* e.g. extern Datum vint2vint2eq(PG_FUNCTION_ARGS);
@@ -243,11 +271,15 @@ v##type##const_type##cmpstr(PG_FUNCTION_ARGS) \
__FUNCTION_OP(type1, XTYPE1, type2, XTYPE2, *, mul) \
__FUNCTION_OP(type1, XTYPE1, type2, XTYPE2, /, div)
-#define _FUNCTION_OP_RCONST(type, XTYPE, const_type, CONST_ARG_MACRO) \
+#define _FUNCTION_OP_CONST(type, XTYPE, const_type, CONST_ARG_MACRO) \
__FUNCTION_OP_RCONST(type, XTYPE, const_type, CONST_ARG_MACRO, +, pl) \
__FUNCTION_OP_RCONST(type, XTYPE, const_type, CONST_ARG_MACRO, -, mi) \
__FUNCTION_OP_RCONST(type, XTYPE, const_type, CONST_ARG_MACRO, *, mul) \
- __FUNCTION_OP_RCONST(type, XTYPE, const_type, CONST_ARG_MACRO, /, div)
+ __FUNCTION_OP_RCONST(type, XTYPE, const_type, CONST_ARG_MACRO, /, div) \
+ __FUNCTION_OP_LCONST(type, XTYPE, const_type, CONST_ARG_MACRO, +, pl) \
+ __FUNCTION_OP_LCONST(type, XTYPE, const_type, CONST_ARG_MACRO, -, mi) \
+ __FUNCTION_OP_LCONST(type, XTYPE, const_type, CONST_ARG_MACRO, *, mul) \
+ __FUNCTION_OP_LCONST(type, XTYPE, const_type, CONST_ARG_MACRO, /, div)
#define _FUNCTION_CMP(type1, XTYPE1, type2, XTYPE2) \
__FUNCTION_CMP(type1, XTYPE1, type2, XTYPE2, ==, eq) \
@@ -274,11 +306,11 @@ v##type##const_type##cmpstr(PG_FUNCTION_ARGS) \
_FUNCTION_OP(type, XTYPE1, float8, Float8)
#define FUNCTION_OP_RCONST(type, XTYPE) \
- _FUNCTION_OP_RCONST(type, XTYPE, int2, PG_GETARG_INT16) \
- _FUNCTION_OP_RCONST(type, XTYPE, int4, PG_GETARG_INT32) \
- _FUNCTION_OP_RCONST(type, XTYPE, int8, PG_GETARG_INT64) \
- _FUNCTION_OP_RCONST(type, XTYPE, float4, PG_GETARG_FLOAT4) \
- _FUNCTION_OP_RCONST(type, XTYPE, float8, PG_GETARG_FLOAT8)
+ _FUNCTION_OP_CONST(type, XTYPE, int2, PG_GETARG_INT16) \
+ _FUNCTION_OP_CONST(type, XTYPE, int4, PG_GETARG_INT32) \
+ _FUNCTION_OP_CONST(type, XTYPE, int8, PG_GETARG_INT64) \
+ _FUNCTION_OP_CONST(type, XTYPE, float4, PG_GETARG_FLOAT4) \
+ _FUNCTION_OP_CONST(type, XTYPE, float8, PG_GETARG_FLOAT8)
#define FUNCTION_CMP(type1, XTYPE1) \
_FUNCTION_CMP(type1, XTYPE1, int2, Int16) \
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/ce2814d4/contrib/vexecutor/vtype.h
----------------------------------------------------------------------
diff --git a/contrib/vexecutor/vtype.h b/contrib/vexecutor/vtype.h
index e8315fc..6c0e8b6 100644
--- a/contrib/vexecutor/vtype.h
+++ b/contrib/vexecutor/vtype.h
@@ -58,7 +58,9 @@ extern Datum v##type1##v##type2##opstr(PG_FUNCTION_ARGS);
*/
#define __FUNCTION_OP_RCONST_HEADER(type, const_type, CONST_ARG_MACRO, opsym, opstr) \
extern Datum v##type##const_type##opstr(PG_FUNCTION_ARGS);
-
+#define __FUNCTION_OP_LCONST_HEADER(type, const_type, CONST_ARG_MACRO, opsym, opstr) \
+extern Datum \
+const_type##v##type##opstr(PG_FUNCTION_ARGS);
/*
* Comparision function for the abstract data types, this MACRO is used for the
* V-types OP V-types.
@@ -81,12 +83,15 @@ extern Datum v##type##const_type##cmpstr(PG_FUNCTION_ARGS);
__FUNCTION_OP_HEADER(type1, type2, *, mul) \
__FUNCTION_OP_HEADER(type1, type2, /, div)
-#define _FUNCTION_OP_RCONST_HEADER(type, const_type, CONST_ARG_MACRO) \
+#define _FUNCTION_OP_CONST_HEADER(type, const_type, CONST_ARG_MACRO) \
__FUNCTION_OP_RCONST_HEADER(type, const_type, CONST_ARG_MACRO, +, pl) \
__FUNCTION_OP_RCONST_HEADER(type, const_type, CONST_ARG_MACRO, -, mi) \
__FUNCTION_OP_RCONST_HEADER(type, const_type, CONST_ARG_MACRO, *, mul) \
- __FUNCTION_OP_RCONST_HEADER(type, const_type, CONST_ARG_MACRO, /, div)
-
+ __FUNCTION_OP_RCONST_HEADER(type, const_type, CONST_ARG_MACRO, /, div) \
+ __FUNCTION_OP_LCONST_HEADER(type, const_type, CONST_ARG_MACRO, +, pl) \
+ __FUNCTION_OP_LCONST_HEADER(type, const_type, CONST_ARG_MACRO, -, mi) \
+ __FUNCTION_OP_LCONST_HEADER(type, const_type, CONST_ARG_MACRO, *, mul) \
+ __FUNCTION_OP_LCONST_HEADER(type, const_type, CONST_ARG_MACRO, /, div)
#define _FUNCTION_CMP_HEADER(type1, type2) \
__FUNCTION_CMP_HEADER(type1, type2, ==, eq) \
@@ -125,12 +130,12 @@ extern Datum v##type##out(PG_FUNCTION_ARGS);
_FUNCTION_OP_HEADER(type, float4) \
_FUNCTION_OP_HEADER(type, float8)
-#define FUNCTION_OP_RCONST_HEADER(type) \
- _FUNCTION_OP_RCONST_HEADER(type, int2, PG_GETARG_INT16) \
- _FUNCTION_OP_RCONST_HEADER(type, int4, PG_GETARG_INT32) \
- _FUNCTION_OP_RCONST_HEADER(type, int8, PG_GETARG_INT64) \
- _FUNCTION_OP_RCONST_HEADER(type, float4, PG_GETARG_FLOAT4) \
- _FUNCTION_OP_RCONST_HEADER(type, float8, PG_GETARG_FLOAT8)
+#define FUNCTION_OP_CONST_HEADER(type) \
+ _FUNCTION_OP_CONST_HEADER(type, int2, PG_GETARG_INT16) \
+ _FUNCTION_OP_CONST_HEADER(type, int4, PG_GETARG_INT32) \
+ _FUNCTION_OP_CONST_HEADER(type, int8, PG_GETARG_INT64) \
+ _FUNCTION_OP_CONST_HEADER(type, float4, PG_GETARG_FLOAT4) \
+ _FUNCTION_OP_CONST_HEADER(type, float8, PG_GETARG_FLOAT8)
#define FUNCTION_CMP_HEADER(type1) \
_FUNCTION_CMP_HEADER(type1, int2) \
@@ -148,7 +153,7 @@ extern Datum v##type##out(PG_FUNCTION_ARGS);
#define FUNCTION_OP_ALL_HEADER(type) \
FUNCTION_OP_HEADER(type) \
- FUNCTION_OP_RCONST_HEADER(type) \
+ FUNCTION_OP_CONST_HEADER(type) \
FUNCTION_CMP_HEADER(type) \
FUNCTION_CMP_RCONST_HEADER(type) \
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/ce2814d4/src/backend/executor/execHHashagg.c
----------------------------------------------------------------------
diff --git a/src/backend/executor/execHHashagg.c b/src/backend/executor/execHHashagg.c
index e519eb9..52c7447 100644
--- a/src/backend/executor/execHHashagg.c
+++ b/src/backend/executor/execHHashagg.c
@@ -83,15 +83,6 @@ struct BatchFileInfo
/* Used for padding */
static char padding_dummy[MAXIMUM_ALIGNOF];
-/*
- * Represent different types for input records to be inserted
- * into the hash table.
- */
-typedef enum InputRecordType
-{
- INPUT_RECORD_TUPLE = 0,
- INPUT_RECORD_GROUP_AND_AGGS,
-} InputRecordType;
#define GET_BUFFER_SIZE(hashtable) \
((hashtable)->entry_buf.nfull_total * (hashtable)->entry_buf.cellbytes + \
@@ -116,10 +107,8 @@ typedef enum InputRecordType
/* Methods that handle batch files */
static SpillSet *createSpillSet(unsigned branching_factor, unsigned parent_hash_bit);
-static SpillSet *read_spill_set(AggState *aggstate);
static int closeSpillFile(AggState *aggstate, SpillSet *spill_set, int file_no);
static int closeSpillFiles(AggState *aggstate, SpillSet *spill_set);
-static int suspendSpillFiles(SpillSet *spill_set);
static int32 writeHashEntry(AggState *aggstate,
BatchFileInfo *file_info,
HashAggEntry *entry);
@@ -130,13 +119,8 @@ static void *readHashEntry(AggState *aggstate,
/* Methods for hash table */
static uint32 calc_hash_value(AggState* aggstate, TupleTableSlot *inputslot);
-static void spill_hash_table(AggState *aggstate);
static void init_agg_hash_iter(HashAggTable* ht);
-static HashAggEntry *lookup_agg_hash_entry(AggState *aggstate, void *input_record,
- InputRecordType input_type, int32 input_size,
- uint32 hashkey, unsigned parent_hash_bit, bool *p_isnew);
static void agg_hash_table_stat_upd(HashAggTable *ht);
-static void reset_agg_hash_table(AggState *aggstate);
static bool agg_hash_reload(AggState *aggstate);
static inline void *mpool_cxt_alloc(void *manager, Size len);
@@ -413,7 +397,7 @@ setGroupAggs(HashAggTable *hashtable, MemTupleBinding *mt_bind, HashAggEntry *en
* or false depending on whether the returned entry is new. Note that
* a new entry will have *initialized* per-group data (Aggref states).
*/
-static HashAggEntry *
+HashAggEntry *
lookup_agg_hash_entry(AggState *aggstate,
void *input_record,
InputRecordType input_type, int32 input_size,
@@ -1117,7 +1101,7 @@ getSpillFile(workfile_set *work_set, SpillSet *set, int file_no, int *p_alloc_si
* suspendSpillFiles -- temporary suspend all spill files so that we
* can have more space for the hash table.
*/
-static int
+int
suspendSpillFiles(SpillSet *spill_set)
{
int file_no;
@@ -1284,7 +1268,7 @@ obtain_spill_set(HashAggTable *hashtable)
*
* The statistics in the hashtable is also updated.
*/
-static SpillSet *
+SpillSet *
read_spill_set(AggState *aggstate)
{
Assert(aggstate != NULL);
@@ -1394,7 +1378,7 @@ read_spill_set(AggState *aggstate)
* write bucket 1, (#batches + 1), (2 * #batches + 1), ... to the batch 1;
* and etc.
*/
-static void
+void
spill_hash_table(AggState *aggstate)
{
HashAggTable *hashtable = aggstate->hhashtable;
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/ce2814d4/src/backend/executor/execProcnode.c
----------------------------------------------------------------------
diff --git a/src/backend/executor/execProcnode.c b/src/backend/executor/execProcnode.c
index 31b6cdd..96a20f8 100644
--- a/src/backend/executor/execProcnode.c
+++ b/src/backend/executor/execProcnode.c
@@ -903,6 +903,7 @@ ExecProcNode(PlanState *node)
Assert(nodeTag(node) >= T_PlanState_Start && nodeTag(node) < T_PlanState_End);
if(vmthd.vectorized_executor_enable
+ && node->plan->vectorized
&& vmthd.ExecProcNode_Hook
&& vmthd.ExecProcNode_Hook(node,&result))
goto Exec_Jmp_Done;
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/ce2814d4/src/backend/executor/nodeAgg.c
----------------------------------------------------------------------
diff --git a/src/backend/executor/nodeAgg.c b/src/backend/executor/nodeAgg.c
index 574dcc6..77808ec 100644
--- a/src/backend/executor/nodeAgg.c
+++ b/src/backend/executor/nodeAgg.c
@@ -152,11 +152,7 @@ typedef struct AggHashEntryData
AggStatePerGroupData pergroup[1]; /* VARIABLE LENGTH ARRAY */
} AggHashEntryData; /* VARIABLE LENGTH STRUCT */
-static void advance_transition_function(AggState *aggstate,
- AggStatePerAgg peraggstate,
- AggStatePerGroup pergroupstate,
- FunctionCallInfoData *fcinfo,
- MemoryManagerContainer *mem_manager);
+
static void process_ordered_aggregate_single(AggState *aggstate,
AggStatePerAgg peraggstate,
AggStatePerGroup pergroupstate);
@@ -168,12 +164,9 @@ static void finalize_aggregate(AggState *aggstate,
AggStatePerGroup pergroupstate,
Datum *resultVal, bool *resultIsNull);
-static void finalize_aggregates(AggState *aggstate, AggStatePerGroup pergroup);
-
static Bitmapset *find_unaggregated_cols(AggState *aggstate);
static bool find_unaggregated_cols_walker(Node *node, Bitmapset **colnos);
static TupleTableSlot *agg_retrieve_direct(AggState *aggstate);
-static TupleTableSlot *agg_retrieve_hash_table(AggState *aggstate);
static void ExecAggExplainEnd(PlanState *planstate, struct StringInfoData *buf);
static int count_extra_agg_slots(Node *node);
static bool count_extra_agg_slots_walker(Node *node, int *count);
@@ -381,7 +374,7 @@ initialize_aggregates(AggState *aggstate,
*
* It doesn't matter which memory context this is called in.
*/
-static void
+void
advance_transition_function(AggState *aggstate,
AggStatePerAgg peraggstate,
AggStatePerGroup pergroupstate,
@@ -819,7 +812,7 @@ process_ordered_aggregate_multi(AggState *aggstate,
* finalize_aggregates
* Compute the final value for all aggregate functions.
*/
-static void
+void
finalize_aggregates(AggState *aggstate, AggStatePerGroup pergroup)
{
AggStatePerAgg peragg = aggstate->peragg;
@@ -1708,7 +1701,7 @@ agg_retrieve_direct(AggState *aggstate)
/*
* ExecAgg for hashed case: retrieve groups from hash table
*/
-static TupleTableSlot *
+TupleTableSlot *
agg_retrieve_hash_table(AggState *aggstate)
{
ExprContext *econtext;
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/ce2814d4/src/include/executor/execHHashagg.h
----------------------------------------------------------------------
diff --git a/src/include/executor/execHHashagg.h b/src/include/executor/execHHashagg.h
index 22fc1a1..b2062e7 100644
--- a/src/include/executor/execHHashagg.h
+++ b/src/include/executor/execHHashagg.h
@@ -43,6 +43,17 @@
typedef uint32 HashKey;
typedef struct BatchFileInfo BatchFileInfo;
+/*
+ * Represent different types for input records to be inserted
+ * into the hash table.
+ */
+typedef enum InputRecordType
+{
+ INPUT_RECORD_TUPLE = 0,
+ INPUT_RECORD_GROUP_AND_AGGS,
+} InputRecordType;
+
+
/* An entry in an Agg hash table.
*
* Each such entry corresponds to a single group and includes the grouping
@@ -256,4 +267,12 @@ calcHashAggTableSizes(double memquota, /* Memory quota in bytes. */
int transpace, /* Est per entry size of by-ref values. */
bool force, /* true => succeed even if work_mem too small */
HashAggTableSizes *out_hats);
+extern int suspendSpillFiles(SpillSet *spill_set);
+extern SpillSet *read_spill_set(AggState *aggstate);
+extern HashAggEntry *lookup_agg_hash_entry(AggState *aggstate, void *input_record,
+ InputRecordType input_type, int32 input_size,
+ uint32 hashkey, unsigned parent_hash_bit, bool *p_isnew);
+extern void spill_hash_table(AggState *aggstate);
+extern void reset_agg_hash_table(AggState *aggstate);
+
#endif
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/ce2814d4/src/include/executor/nodeAgg.h
----------------------------------------------------------------------
diff --git a/src/include/executor/nodeAgg.h b/src/include/executor/nodeAgg.h
index 74ccf3a..5d4ac13 100644
--- a/src/include/executor/nodeAgg.h
+++ b/src/include/executor/nodeAgg.h
@@ -217,5 +217,12 @@ static inline gpmon_packet_t * GpmonPktFromAggState(AggState *node)
extern List *combineAggrefArgs(Aggref *aggref, List **sort_clauses);
extern List *combinePercentileArgs(PercentileExpr *p);
+extern void finalize_aggregates(AggState *aggstate, AggStatePerGroup pergroup);
+extern TupleTableSlot *agg_retrieve_hash_table(AggState *aggstate);
+extern void advance_transition_function(AggState *aggstate,
+ AggStatePerAgg peraggstate,
+ AggStatePerGroup pergroupstate,
+ FunctionCallInfoData *fcinfo,
+ MemoryManagerContainer *mem_manager);
#endif /* NODEAGG_H */
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/ce2814d4/src/include/executor/nodeMotion.h
----------------------------------------------------------------------
diff --git a/src/include/executor/nodeMotion.h b/src/include/executor/nodeMotion.h
index 56d3db1..5352f15 100644
--- a/src/include/executor/nodeMotion.h
+++ b/src/include/executor/nodeMotion.h
@@ -12,7 +12,6 @@
#ifndef NODEMOTION_H
#define NODEMOTION_H
-#include "cdb/cdbhash.h"
#include "nodes/execnodes.h"
extern int ExecCountSlotsMotion(Motion *node);
[3/9] incubator-hawq git commit: HAWQ-1612. Implement vectorized
aggregate functions, such as avg/sum/count.
Posted by rl...@apache.org.
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/ce2814d4/src/test/feature/vexecutor/ans/drop_type.ans
----------------------------------------------------------------------
diff --git a/src/test/feature/vexecutor/ans/drop_type.ans b/src/test/feature/vexecutor/ans/drop_type.ans
index c50f79f..5a55898 100644
--- a/src/test/feature/vexecutor/ans/drop_type.ans
+++ b/src/test/feature/vexecutor/ans/drop_type.ans
@@ -2,1118 +2,1254 @@
SET SEARCH_PATH=TestVexecutor_vadt;
SET
-- end_ignore
--- drop types cascade
+--drop agg functions
+--drop the previous funcitons
+DROP AGGREGATE IF EXISTS sum(vint2);
+DROP AGGREGATE
+DROP AGGREGATE IF EXISTS sum(vint4);
+DROP AGGREGATE
+DROP AGGREGATE IF EXISTS sum(vint8);
+DROP AGGREGATE
+DROP AGGREGATE IF EXISTS sum(vfloat4);
+DROP AGGREGATE
+DROP AGGREGATE IF EXISTS sum(vfloat8);
+DROP AGGREGATE
+DROP AGGREGATE IF EXISTS avg(vint2);
+DROP AGGREGATE
+DROP AGGREGATE IF EXISTS avg(vint4);
+DROP AGGREGATE
+DROP AGGREGATE IF EXISTS avg(vint8);
+DROP AGGREGATE
+DROP AGGREGATE IF EXISTS avg(vfloat4);
+DROP AGGREGATE
+DROP AGGREGATE IF EXISTS avg(vfloat8);
+DROP AGGREGATE
+DROP AGGREGATE IF EXISTS count(vint2);
+DROP AGGREGATE
+DROP AGGREGATE IF EXISTS count(vint4);
+DROP AGGREGATE
+DROP AGGREGATE IF EXISTS count(vint8);
+DROP AGGREGATE
+DROP AGGREGATE IF EXISTS count(vfloat4);
+DROP AGGREGATE
+DROP AGGREGATE IF EXISTS count(vfloat8);
+DROP AGGREGATE
+DROP AGGREGATE IF EXISTS veccount(*);
+DROP AGGREGATE
+DROP FUNCTION IF EXISTS vint2_accum(int8, vint2);
+DROP FUNCTION
+DROP FUNCTION IF EXISTS vint4_accum(int8, vint4);
+DROP FUNCTION
+DROP FUNCTION IF EXISTS vint8_accum(numeric, vint8);
+DROP FUNCTION
+DROP FUNCTION IF EXISTS vfloat4_accum(float4, vfloat4);
+DROP FUNCTION
+DROP FUNCTION IF EXISTS vfloat8_accum(float8, vfloat8);
+DROP FUNCTION
+DROP FUNCTION IF EXISTS vint2_avg_accum(bytea, vint2);
+DROP FUNCTION
+DROP FUNCTION IF EXISTS vint4_avg_accum(bytea, vint4);
+DROP FUNCTION
+DROP FUNCTION IF EXISTS vint8_avg_accum(bytea, vint8);
+DROP FUNCTION
+DROP FUNCTION IF EXISTS vfloat4_avg_accum(bytea, vfloat4);
+DROP FUNCTION
+DROP FUNCTION IF EXISTS vfloat8_avg_accum(bytea, vfloat8);
+DROP FUNCTION
+DROP FUNCTION IF EXISTS vint2_inc(int8, vint2);
+DROP FUNCTION
+DROP FUNCTION IF EXISTS vint4_inc(int8, vint4);
+DROP FUNCTION
+DROP FUNCTION IF EXISTS vint8_inc(int8, vint8);
+DROP FUNCTION
+DROP FUNCTION IF EXISTS vfloat4_inc(int8, vfloat4);
+DROP FUNCTION
+DROP FUNCTION IF EXISTS vfloat8_inc(int8, vfloat8);
+DROP FUNCTION
+DROP FUNCTION IF EXISTS vec_inc_any(int8);
+DROP FUNCTION
drop type vint2 cascade;
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator /(vint2,double precision)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator *(double precision,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2float8div(vint2,double precision)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator *(vint2,double precision)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator /(double precision,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2float8mul(vint2,double precision)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator -(vint2,double precision)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator +(double precision,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2float8mi(vint2,double precision)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator +(vint2,double precision)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator -(double precision,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2float8pl(vint2,double precision)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator /(vint2,real)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator *(real,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2float4div(vint2,real)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator *(vint2,real)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator /(real,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2float4mul(vint2,real)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator -(vint2,real)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator +(real,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2float4mi(vint2,real)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator +(vint2,real)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator -(real,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2float4pl(vint2,real)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator /(vint2,bigint)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator *(bigint,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2int8div(vint2,bigint)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator *(vint2,bigint)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator /(bigint,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2int8mul(vint2,bigint)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator -(vint2,bigint)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator +(bigint,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2int8mi(vint2,bigint)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator +(vint2,bigint)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator -(bigint,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2int8pl(vint2,bigint)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator /(vint2,integer)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator *(integer,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2int4div(vint2,integer)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator *(vint2,integer)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator /(integer,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2int4mul(vint2,integer)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator -(vint2,integer)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator +(integer,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2int4mi(vint2,integer)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator +(vint2,integer)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator -(integer,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2int4pl(vint2,integer)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator /(vint2,smallint)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator *(smallint,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2int2div(vint2,smallint)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator *(vint2,smallint)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator /(smallint,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2int2mul(vint2,smallint)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator -(vint2,smallint)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator +(smallint,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2int2mi(vint2,smallint)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator +(vint2,smallint)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator -(smallint,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2int2pl(vint2,smallint)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator /(vint2,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2vint2div(vint2,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator *(vint2,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2vint2mul(vint2,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator -(vint2,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2vint2mi(vint2,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator +(vint2,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2vint2pl(vint2,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <=(vfloat8,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vfloat8vint2le(vfloat8,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <(vfloat8,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vfloat8vint2lt(vfloat8,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <>(vfloat8,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vfloat8vint2ne(vfloat8,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator =(vfloat8,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vfloat8vint2eq(vfloat8,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator >=(vfloat8,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vfloat8vint2ge(vfloat8,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator >(vfloat8,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vfloat8vint2gt(vfloat8,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <=(vfloat4,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vfloat4vint2le(vfloat4,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <(vfloat4,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vfloat4vint2lt(vfloat4,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <>(vfloat4,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vfloat4vint2ne(vfloat4,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator =(vfloat4,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vfloat4vint2eq(vfloat4,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator >=(vfloat4,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vfloat4vint2ge(vfloat4,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator >(vfloat4,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vfloat4vint2gt(vfloat4,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <=(vint8,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint8vint2le(vint8,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <(vint8,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint8vint2lt(vint8,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <>(vint8,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint8vint2ne(vint8,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator =(vint8,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint8vint2eq(vint8,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator >=(vint8,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint8vint2ge(vint8,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator >(vint8,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint8vint2gt(vint8,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <=(vint4,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint4vint2le(vint4,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <(vint4,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint4vint2lt(vint4,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <>(vint4,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint4vint2ne(vint4,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator =(vint4,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint4vint2eq(vint4,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator >=(vint4,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint4vint2ge(vint4,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator >(vint4,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint4vint2gt(vint4,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <=(vint2,double precision)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator >(double precision,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2float8le(vint2,double precision)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <(vint2,double precision)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator >=(double precision,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2float8lt(vint2,double precision)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <>(vint2,double precision)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator =(double precision,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2float8ne(vint2,double precision)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator =(vint2,double precision)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <>(double precision,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2float8eq(vint2,double precision)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator >=(vint2,double precision)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <(double precision,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2float8ge(vint2,double precision)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator >(vint2,double precision)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <=(double precision,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2float8gt(vint2,double precision)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <=(vint2,real)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator >(real,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2float4le(vint2,real)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <(vint2,real)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator >=(real,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2float4lt(vint2,real)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <>(vint2,real)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator =(real,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2float4ne(vint2,real)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator =(vint2,real)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <>(real,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2float4eq(vint2,real)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator >=(vint2,real)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <(real,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2float4ge(vint2,real)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator >(vint2,real)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <=(real,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2float4gt(vint2,real)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <=(vint2,bigint)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator >(bigint,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2int8le(vint2,bigint)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <(vint2,bigint)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator >=(bigint,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2int8lt(vint2,bigint)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <>(vint2,bigint)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator =(bigint,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2int8ne(vint2,bigint)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator =(vint2,bigint)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <>(bigint,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2int8eq(vint2,bigint)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator >=(vint2,bigint)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <(bigint,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2int8ge(vint2,bigint)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator >(vint2,bigint)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <=(bigint,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2int8gt(vint2,bigint)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <=(vint2,integer)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator >(integer,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2int4le(vint2,integer)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <(vint2,integer)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator >=(integer,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2int4lt(vint2,integer)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <>(vint2,integer)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator =(integer,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2int4ne(vint2,integer)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator =(vint2,integer)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <>(integer,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2int4eq(vint2,integer)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator >=(vint2,integer)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <(integer,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2int4ge(vint2,integer)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator >(vint2,integer)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <=(integer,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2int4gt(vint2,integer)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <=(vint2,smallint)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator >(smallint,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2int2le(vint2,smallint)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <(vint2,smallint)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator >=(smallint,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2int2lt(vint2,smallint)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <>(vint2,smallint)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator =(smallint,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2int2ne(vint2,smallint)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator =(vint2,smallint)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <>(smallint,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2int2eq(vint2,smallint)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator >=(vint2,smallint)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <(smallint,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2int2ge(vint2,smallint)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator >(vint2,smallint)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <=(smallint,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2int2gt(vint2,smallint)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <=(vint2,vfloat8)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2vfloat8le(vint2,vfloat8)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <(vint2,vfloat8)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2vfloat8lt(vint2,vfloat8)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <>(vint2,vfloat8)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2vfloat8ne(vint2,vfloat8)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator =(vint2,vfloat8)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2vfloat8eq(vint2,vfloat8)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator >=(vint2,vfloat8)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2vfloat8ge(vint2,vfloat8)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator >(vint2,vfloat8)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2vfloat8gt(vint2,vfloat8)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <=(vint2,vfloat4)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2vfloat4le(vint2,vfloat4)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <(vint2,vfloat4)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2vfloat4lt(vint2,vfloat4)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <>(vint2,vfloat4)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2vfloat4ne(vint2,vfloat4)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator =(vint2,vfloat4)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2vfloat4eq(vint2,vfloat4)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator >=(vint2,vfloat4)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2vfloat4ge(vint2,vfloat4)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator >(vint2,vfloat4)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2vfloat4gt(vint2,vfloat4)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <=(vint2,vint8)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2vint8le(vint2,vint8)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <(vint2,vint8)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2vint8lt(vint2,vint8)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <>(vint2,vint8)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2vint8ne(vint2,vint8)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator =(vint2,vint8)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2vint8eq(vint2,vint8)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator >=(vint2,vint8)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2vint8ge(vint2,vint8)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator >(vint2,vint8)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2vint8gt(vint2,vint8)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <=(vint2,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2vint4le(vint2,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <(vint2,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2vint4lt(vint2,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <>(vint2,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2vint4ne(vint2,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator =(vint2,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2vint4eq(vint2,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator >=(vint2,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2vint4ge(vint2,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator >(vint2,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2vint4gt(vint2,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <=(vint2,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2vint2le(vint2,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <(vint2,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2vint2lt(vint2,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator <>(vint2,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2vint2ne(vint2,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator =(vint2,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2vint2eq(vint2,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator >=(vint2,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2vint2ge(vint2,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to operator >(vint2,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2vint2gt(vint2,vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2out(vint2)
-psql:/tmp/TestVexecutor_vadt.sql:5: NOTICE: drop cascades to function vint2in(cstring)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator /(smallint,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function int2vint2div(smallint,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator *(smallint,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function int2vint2mul(smallint,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator -(smallint,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function int2vint2mi(smallint,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator +(smallint,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function int2vint2pl(smallint,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator /(vint2,double precision)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator *(double precision,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2float8div(vint2,double precision)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator *(vint2,double precision)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator /(double precision,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2float8mul(vint2,double precision)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator -(vint2,double precision)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator +(double precision,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2float8mi(vint2,double precision)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator +(vint2,double precision)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator -(double precision,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2float8pl(vint2,double precision)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator /(vint2,real)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator *(real,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2float4div(vint2,real)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator *(vint2,real)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator /(real,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2float4mul(vint2,real)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator -(vint2,real)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator +(real,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2float4mi(vint2,real)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator +(vint2,real)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator -(real,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2float4pl(vint2,real)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator /(vint2,bigint)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator *(bigint,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2int8div(vint2,bigint)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator *(vint2,bigint)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator /(bigint,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2int8mul(vint2,bigint)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator -(vint2,bigint)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator +(bigint,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2int8mi(vint2,bigint)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator +(vint2,bigint)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator -(bigint,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2int8pl(vint2,bigint)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator /(vint2,integer)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator *(integer,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2int4div(vint2,integer)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator *(vint2,integer)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator /(integer,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2int4mul(vint2,integer)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator -(vint2,integer)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator +(integer,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2int4mi(vint2,integer)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator +(vint2,integer)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator -(integer,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2int4pl(vint2,integer)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator /(vint2,smallint)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2int2div(vint2,smallint)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator *(vint2,smallint)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2int2mul(vint2,smallint)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator -(vint2,smallint)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2int2mi(vint2,smallint)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator +(vint2,smallint)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2int2pl(vint2,smallint)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator /(vint2,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2vint2div(vint2,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator *(vint2,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2vint2mul(vint2,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator -(vint2,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2vint2mi(vint2,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator +(vint2,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2vint2pl(vint2,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <=(vfloat8,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vfloat8vint2le(vfloat8,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <(vfloat8,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vfloat8vint2lt(vfloat8,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <>(vfloat8,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vfloat8vint2ne(vfloat8,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator =(vfloat8,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vfloat8vint2eq(vfloat8,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator >=(vfloat8,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vfloat8vint2ge(vfloat8,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator >(vfloat8,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vfloat8vint2gt(vfloat8,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <=(vfloat4,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vfloat4vint2le(vfloat4,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <(vfloat4,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vfloat4vint2lt(vfloat4,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <>(vfloat4,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vfloat4vint2ne(vfloat4,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator =(vfloat4,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vfloat4vint2eq(vfloat4,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator >=(vfloat4,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vfloat4vint2ge(vfloat4,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator >(vfloat4,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vfloat4vint2gt(vfloat4,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <=(vint8,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint8vint2le(vint8,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <(vint8,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint8vint2lt(vint8,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <>(vint8,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint8vint2ne(vint8,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator =(vint8,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint8vint2eq(vint8,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator >=(vint8,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint8vint2ge(vint8,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator >(vint8,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint8vint2gt(vint8,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <=(vint4,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint4vint2le(vint4,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <(vint4,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint4vint2lt(vint4,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <>(vint4,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint4vint2ne(vint4,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator =(vint4,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint4vint2eq(vint4,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator >=(vint4,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint4vint2ge(vint4,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator >(vint4,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint4vint2gt(vint4,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <=(vint2,double precision)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator >(double precision,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2float8le(vint2,double precision)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <(vint2,double precision)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator >=(double precision,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2float8lt(vint2,double precision)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <>(vint2,double precision)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator =(double precision,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2float8ne(vint2,double precision)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator =(vint2,double precision)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <>(double precision,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2float8eq(vint2,double precision)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator >=(vint2,double precision)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <(double precision,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2float8ge(vint2,double precision)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator >(vint2,double precision)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <=(double precision,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2float8gt(vint2,double precision)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <=(vint2,real)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator >(real,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2float4le(vint2,real)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <(vint2,real)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator >=(real,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2float4lt(vint2,real)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <>(vint2,real)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator =(real,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2float4ne(vint2,real)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator =(vint2,real)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <>(real,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2float4eq(vint2,real)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator >=(vint2,real)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <(real,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2float4ge(vint2,real)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator >(vint2,real)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <=(real,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2float4gt(vint2,real)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <=(vint2,bigint)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator >(bigint,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2int8le(vint2,bigint)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <(vint2,bigint)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator >=(bigint,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2int8lt(vint2,bigint)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <>(vint2,bigint)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator =(bigint,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2int8ne(vint2,bigint)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator =(vint2,bigint)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <>(bigint,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2int8eq(vint2,bigint)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator >=(vint2,bigint)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <(bigint,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2int8ge(vint2,bigint)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator >(vint2,bigint)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <=(bigint,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2int8gt(vint2,bigint)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <=(vint2,integer)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator >(integer,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2int4le(vint2,integer)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <(vint2,integer)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator >=(integer,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2int4lt(vint2,integer)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <>(vint2,integer)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator =(integer,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2int4ne(vint2,integer)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator =(vint2,integer)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <>(integer,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2int4eq(vint2,integer)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator >=(vint2,integer)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <(integer,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2int4ge(vint2,integer)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator >(vint2,integer)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <=(integer,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2int4gt(vint2,integer)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <=(vint2,smallint)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator >(smallint,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2int2le(vint2,smallint)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <(vint2,smallint)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator >=(smallint,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2int2lt(vint2,smallint)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <>(vint2,smallint)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator =(smallint,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2int2ne(vint2,smallint)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator =(vint2,smallint)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <>(smallint,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2int2eq(vint2,smallint)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator >=(vint2,smallint)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <(smallint,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2int2ge(vint2,smallint)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator >(vint2,smallint)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <=(smallint,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2int2gt(vint2,smallint)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <=(vint2,vfloat8)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2vfloat8le(vint2,vfloat8)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <(vint2,vfloat8)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2vfloat8lt(vint2,vfloat8)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <>(vint2,vfloat8)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2vfloat8ne(vint2,vfloat8)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator =(vint2,vfloat8)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2vfloat8eq(vint2,vfloat8)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator >=(vint2,vfloat8)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2vfloat8ge(vint2,vfloat8)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator >(vint2,vfloat8)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2vfloat8gt(vint2,vfloat8)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <=(vint2,vfloat4)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2vfloat4le(vint2,vfloat4)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <(vint2,vfloat4)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2vfloat4lt(vint2,vfloat4)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <>(vint2,vfloat4)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2vfloat4ne(vint2,vfloat4)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator =(vint2,vfloat4)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2vfloat4eq(vint2,vfloat4)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator >=(vint2,vfloat4)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2vfloat4ge(vint2,vfloat4)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator >(vint2,vfloat4)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2vfloat4gt(vint2,vfloat4)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <=(vint2,vint8)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2vint8le(vint2,vint8)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <(vint2,vint8)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2vint8lt(vint2,vint8)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <>(vint2,vint8)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2vint8ne(vint2,vint8)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator =(vint2,vint8)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2vint8eq(vint2,vint8)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator >=(vint2,vint8)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2vint8ge(vint2,vint8)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator >(vint2,vint8)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2vint8gt(vint2,vint8)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <=(vint2,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2vint4le(vint2,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <(vint2,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2vint4lt(vint2,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <>(vint2,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2vint4ne(vint2,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator =(vint2,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2vint4eq(vint2,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator >=(vint2,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2vint4ge(vint2,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator >(vint2,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2vint4gt(vint2,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <=(vint2,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2vint2le(vint2,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <(vint2,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2vint2lt(vint2,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator <>(vint2,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2vint2ne(vint2,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator =(vint2,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2vint2eq(vint2,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator >=(vint2,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2vint2ge(vint2,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to operator >(vint2,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2vint2gt(vint2,vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2out(vint2)
+psql:/tmp/TestVexecutor_vadt.sql:46: NOTICE: drop cascades to function vint2in(cstring)
DROP TYPE
drop type vint4 cascade;
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator /(vint4,double precision)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator *(double precision,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4float8div(vint4,double precision)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator *(vint4,double precision)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator /(double precision,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4float8mul(vint4,double precision)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator -(vint4,double precision)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator +(double precision,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4float8mi(vint4,double precision)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator +(vint4,double precision)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator -(double precision,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4float8pl(vint4,double precision)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator /(vint4,real)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator *(real,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4float4div(vint4,real)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator *(vint4,real)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator /(real,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4float4mul(vint4,real)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator -(vint4,real)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator +(real,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4float4mi(vint4,real)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator +(vint4,real)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator -(real,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4float4pl(vint4,real)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator /(vint4,bigint)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator *(bigint,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4int8div(vint4,bigint)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator *(vint4,bigint)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator /(bigint,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4int8mul(vint4,bigint)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator -(vint4,bigint)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator +(bigint,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4int8mi(vint4,bigint)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator +(vint4,bigint)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator -(bigint,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4int8pl(vint4,bigint)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator /(vint4,integer)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator *(integer,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4int4div(vint4,integer)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator *(vint4,integer)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator /(integer,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4int4mul(vint4,integer)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator -(vint4,integer)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator +(integer,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4int4mi(vint4,integer)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator +(vint4,integer)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator -(integer,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4int4pl(vint4,integer)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator /(vint4,smallint)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator *(smallint,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4int2div(vint4,smallint)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator *(vint4,smallint)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator /(smallint,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4int2mul(vint4,smallint)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator -(vint4,smallint)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator +(smallint,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4int2mi(vint4,smallint)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator +(vint4,smallint)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator -(smallint,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4int2pl(vint4,smallint)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator /(vint4,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4vint4div(vint4,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator *(vint4,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4vint4mul(vint4,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator -(vint4,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4vint4mi(vint4,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator +(vint4,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4vint4pl(vint4,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <=(vfloat8,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vfloat8vint4le(vfloat8,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <(vfloat8,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vfloat8vint4lt(vfloat8,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <>(vfloat8,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vfloat8vint4ne(vfloat8,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator =(vfloat8,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vfloat8vint4eq(vfloat8,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator >=(vfloat8,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vfloat8vint4ge(vfloat8,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator >(vfloat8,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vfloat8vint4gt(vfloat8,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <=(vfloat4,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vfloat4vint4le(vfloat4,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <(vfloat4,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vfloat4vint4lt(vfloat4,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <>(vfloat4,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vfloat4vint4ne(vfloat4,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator =(vfloat4,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vfloat4vint4eq(vfloat4,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator >=(vfloat4,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vfloat4vint4ge(vfloat4,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator >(vfloat4,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vfloat4vint4gt(vfloat4,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <=(vint8,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint8vint4le(vint8,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <(vint8,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint8vint4lt(vint8,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <>(vint8,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint8vint4ne(vint8,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator =(vint8,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint8vint4eq(vint8,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator >=(vint8,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint8vint4ge(vint8,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator >(vint8,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint8vint4gt(vint8,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <=(vint4,double precision)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator >(double precision,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4float8le(vint4,double precision)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <(vint4,double precision)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator >=(double precision,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4float8lt(vint4,double precision)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <>(vint4,double precision)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator =(double precision,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4float8ne(vint4,double precision)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator =(vint4,double precision)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <>(double precision,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4float8eq(vint4,double precision)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator >=(vint4,double precision)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <(double precision,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4float8ge(vint4,double precision)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator >(vint4,double precision)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <=(double precision,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4float8gt(vint4,double precision)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <=(vint4,real)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator >(real,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4float4le(vint4,real)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <(vint4,real)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator >=(real,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4float4lt(vint4,real)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <>(vint4,real)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator =(real,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4float4ne(vint4,real)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator =(vint4,real)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <>(real,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4float4eq(vint4,real)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator >=(vint4,real)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <(real,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4float4ge(vint4,real)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator >(vint4,real)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <=(real,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4float4gt(vint4,real)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <=(vint4,bigint)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator >(bigint,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4int8le(vint4,bigint)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <(vint4,bigint)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator >=(bigint,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4int8lt(vint4,bigint)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <>(vint4,bigint)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator =(bigint,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4int8ne(vint4,bigint)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator =(vint4,bigint)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <>(bigint,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4int8eq(vint4,bigint)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator >=(vint4,bigint)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <(bigint,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4int8ge(vint4,bigint)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator >(vint4,bigint)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <=(bigint,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4int8gt(vint4,bigint)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <=(vint4,integer)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator >(integer,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4int4le(vint4,integer)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <(vint4,integer)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator >=(integer,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4int4lt(vint4,integer)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <>(vint4,integer)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator =(integer,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4int4ne(vint4,integer)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator =(vint4,integer)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <>(integer,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4int4eq(vint4,integer)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator >=(vint4,integer)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <(integer,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4int4ge(vint4,integer)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator >(vint4,integer)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <=(integer,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4int4gt(vint4,integer)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <=(vint4,smallint)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator >(smallint,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4int2le(vint4,smallint)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <(vint4,smallint)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator >=(smallint,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4int2lt(vint4,smallint)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <>(vint4,smallint)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator =(smallint,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4int2ne(vint4,smallint)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator =(vint4,smallint)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <>(smallint,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4int2eq(vint4,smallint)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator >=(vint4,smallint)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <(smallint,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4int2ge(vint4,smallint)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator >(vint4,smallint)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <=(smallint,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4int2gt(vint4,smallint)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <=(vint4,vfloat8)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4vfloat8le(vint4,vfloat8)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <(vint4,vfloat8)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4vfloat8lt(vint4,vfloat8)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <>(vint4,vfloat8)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4vfloat8ne(vint4,vfloat8)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator =(vint4,vfloat8)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4vfloat8eq(vint4,vfloat8)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator >=(vint4,vfloat8)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4vfloat8ge(vint4,vfloat8)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator >(vint4,vfloat8)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4vfloat8gt(vint4,vfloat8)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <=(vint4,vfloat4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4vfloat4le(vint4,vfloat4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <(vint4,vfloat4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4vfloat4lt(vint4,vfloat4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <>(vint4,vfloat4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4vfloat4ne(vint4,vfloat4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator =(vint4,vfloat4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4vfloat4eq(vint4,vfloat4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator >=(vint4,vfloat4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4vfloat4ge(vint4,vfloat4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator >(vint4,vfloat4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4vfloat4gt(vint4,vfloat4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <=(vint4,vint8)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4vint8le(vint4,vint8)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <(vint4,vint8)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4vint8lt(vint4,vint8)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <>(vint4,vint8)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4vint8ne(vint4,vint8)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator =(vint4,vint8)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4vint8eq(vint4,vint8)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator >=(vint4,vint8)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4vint8ge(vint4,vint8)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator >(vint4,vint8)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4vint8gt(vint4,vint8)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <=(vint4,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4vint4le(vint4,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <(vint4,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4vint4lt(vint4,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator <>(vint4,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4vint4ne(vint4,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator =(vint4,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4vint4eq(vint4,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator >=(vint4,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4vint4ge(vint4,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to operator >(vint4,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4vint4gt(vint4,vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4out(vint4)
-psql:/tmp/TestVexecutor_vadt.sql:6: NOTICE: drop cascades to function vint4in(cstring)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator -(vdateadt,date)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vdateadt_mi_dateadt(vdateadt,date)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator -(vdateadt,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator -(vint4,vdateadt)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vdateadt_mii(vdateadt,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator +(vdateadt,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator +(vint4,vdateadt)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vdateadt_pli(vdateadt,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator -(vdateadt,vdateadt)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vdateadt_mi(vdateadt,vdateadt)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator /(integer,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function int4vint4div(integer,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator *(integer,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function int4vint4mul(integer,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator -(integer,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function int4vint4mi(integer,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator +(integer,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function int4vint4pl(integer,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator /(vint4,double precision)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator *(double precision,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vint4float8div(vint4,double precision)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator *(vint4,double precision)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator /(double precision,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vint4float8mul(vint4,double precision)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator -(vint4,double precision)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator +(double precision,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vint4float8mi(vint4,double precision)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator +(vint4,double precision)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator -(double precision,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vint4float8pl(vint4,double precision)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator /(vint4,real)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator *(real,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vint4float4div(vint4,real)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator *(vint4,real)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator /(real,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vint4float4mul(vint4,real)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator -(vint4,real)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator +(real,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vint4float4mi(vint4,real)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator +(vint4,real)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator -(real,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vint4float4pl(vint4,real)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator /(vint4,bigint)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator *(bigint,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vint4int8div(vint4,bigint)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator *(vint4,bigint)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator /(bigint,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vint4int8mul(vint4,bigint)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator -(vint4,bigint)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator +(bigint,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vint4int8mi(vint4,bigint)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator +(vint4,bigint)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator -(bigint,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vint4int8pl(vint4,bigint)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator /(vint4,integer)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vint4int4div(vint4,integer)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator *(vint4,integer)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vint4int4mul(vint4,integer)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator -(vint4,integer)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vint4int4mi(vint4,integer)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator +(vint4,integer)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vint4int4pl(vint4,integer)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator /(vint4,smallint)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator *(smallint,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vint4int2div(vint4,smallint)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator *(vint4,smallint)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator /(smallint,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vint4int2mul(vint4,smallint)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator -(vint4,smallint)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator +(smallint,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vint4int2mi(vint4,smallint)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator +(vint4,smallint)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator -(smallint,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vint4int2pl(vint4,smallint)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator /(vint4,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vint4vint4div(vint4,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator *(vint4,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vint4vint4mul(vint4,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator -(vint4,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vint4vint4mi(vint4,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator +(vint4,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vint4vint4pl(vint4,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator <=(vfloat8,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vfloat8vint4le(vfloat8,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator <(vfloat8,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vfloat8vint4lt(vfloat8,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator <>(vfloat8,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vfloat8vint4ne(vfloat8,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator =(vfloat8,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vfloat8vint4eq(vfloat8,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator >=(vfloat8,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vfloat8vint4ge(vfloat8,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator >(vfloat8,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vfloat8vint4gt(vfloat8,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator <=(vfloat4,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vfloat4vint4le(vfloat4,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator <(vfloat4,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vfloat4vint4lt(vfloat4,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator <>(vfloat4,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vfloat4vint4ne(vfloat4,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator =(vfloat4,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vfloat4vint4eq(vfloat4,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator >=(vfloat4,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vfloat4vint4ge(vfloat4,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator >(vfloat4,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vfloat4vint4gt(vfloat4,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator <=(vint8,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vint8vint4le(vint8,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator <(vint8,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vint8vint4lt(vint8,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator <>(vint8,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vint8vint4ne(vint8,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator =(vint8,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vint8vint4eq(vint8,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator >=(vint8,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vint8vint4ge(vint8,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator >(vint8,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vint8vint4gt(vint8,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator <=(vint4,double precision)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator >(double precision,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vint4float8le(vint4,double precision)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator <(vint4,double precision)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator >=(double precision,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vint4float8lt(vint4,double precision)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator <>(vint4,double precision)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator =(double precision,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vint4float8ne(vint4,double precision)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator =(vint4,double precision)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator <>(double precision,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vint4float8eq(vint4,double precision)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator >=(vint4,double precision)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to operator <(double precision,vint4)
+psql:/tmp/TestVexecutor_vadt.sql:47: NOTICE: drop cascades to function vint4float8ge(vint4,double precision)
+psql:/tmp/TestVexecutor_vadt.sql:47:
<TRUNCATED>
[4/9] incubator-hawq git commit: HAWQ-1612. Implement vectorized
aggregate functions, such as avg/sum/count.
Posted by rl...@apache.org.
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/ce2814d4/src/test/feature/vexecutor/ans/create_type_vadt.ans
----------------------------------------------------------------------
diff --git a/src/test/feature/vexecutor/ans/create_type_vadt.ans b/src/test/feature/vexecutor/ans/create_type_vadt.ans
new file mode 100644
index 0000000..a93be35
--- /dev/null
+++ b/src/test/feature/vexecutor/ans/create_type_vadt.ans
@@ -0,0 +1,2014 @@
+-- start_ignore
+SET SEARCH_PATH=TestVexecutor_vadt;
+SET
+-- end_ignore
+-- create vectorized types
+CREATE TYPE vint2;
+CREATE TYPE
+CREATE FUNCTION vint2in(cstring) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+psql:/tmp/TestVexecutor_vadt.sql:9: NOTICE: return type vint2 is only a shell
+CREATE FUNCTION
+CREATE FUNCTION vint2out(vint2) RETURNS cstring AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+psql:/tmp/TestVexecutor_vadt.sql:10: NOTICE: argument type vint2 is only a shell
+CREATE FUNCTION
+CREATE TYPE vint2 ( INPUT = vint2in, OUTPUT = vint2out, element = int2, storage=external );
+CREATE TYPE
+CREATE TYPE vint4;
+CREATE TYPE
+CREATE FUNCTION vint4in(cstring) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+psql:/tmp/TestVexecutor_vadt.sql:15: NOTICE: return type vint4 is only a shell
+CREATE FUNCTION
+CREATE FUNCTION vint4out(vint4) RETURNS cstring AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+psql:/tmp/TestVexecutor_vadt.sql:16: NOTICE: argument type vint4 is only a shell
+CREATE FUNCTION
+CREATE TYPE vint4 ( INPUT = vint4in, OUTPUT = vint4out, element = int4, storage=external );
+CREATE TYPE
+CREATE TYPE vint8;
+CREATE TYPE
+CREATE FUNCTION vint8in(cstring) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+psql:/tmp/TestVexecutor_vadt.sql:20: NOTICE: return type vint8 is only a shell
+CREATE FUNCTION
+CREATE FUNCTION vint8out(vint8) RETURNS cstring AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+psql:/tmp/TestVexecutor_vadt.sql:21: NOTICE: argument type vint8 is only a shell
+CREATE FUNCTION
+CREATE TYPE vint8 ( INPUT = vint8in, OUTPUT = vint8out, element = int8, storage=external );
+CREATE TYPE
+CREATE TYPE vfloat4;
+CREATE TYPE
+CREATE FUNCTION vfloat4in(cstring) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+psql:/tmp/TestVexecutor_vadt.sql:26: NOTICE: return type vfloat4 is only a shell
+CREATE FUNCTION
+CREATE FUNCTION vfloat4out(vfloat4) RETURNS cstring AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+psql:/tmp/TestVexecutor_vadt.sql:27: NOTICE: argument type vfloat4 is only a shell
+CREATE FUNCTION
+CREATE TYPE vfloat4 ( INPUT = vfloat4in, OUTPUT = vfloat4out, element = float4, storage=external );
+CREATE TYPE
+CREATE TYPE vfloat8;
+CREATE TYPE
+CREATE FUNCTION vfloat8in(cstring) RETURNS vfloat8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+psql:/tmp/TestVexecutor_vadt.sql:32: NOTICE: return type vfloat8 is only a shell
+CREATE FUNCTION
+CREATE FUNCTION vfloat8out(vfloat8) RETURNS cstring AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+psql:/tmp/TestVexecutor_vadt.sql:33: NOTICE: argument type vfloat8 is only a shell
+CREATE FUNCTION
+CREATE TYPE vfloat8 ( INPUT = vfloat8in, OUTPUT = vfloat8out, element = float8, storage=external );
+CREATE TYPE
+CREATE TYPE vbool;
+CREATE TYPE
+CREATE FUNCTION vboolin(cstring) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+psql:/tmp/TestVexecutor_vadt.sql:38: NOTICE: return type vbool is only a shell
+CREATE FUNCTION
+CREATE FUNCTION vboolout(vbool) RETURNS cstring AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+psql:/tmp/TestVexecutor_vadt.sql:39: NOTICE: argument type vbool is only a shell
+CREATE FUNCTION
+CREATE TYPE vbool ( INPUT = vboolin, OUTPUT = vboolout, element = bool, storage=external );
+CREATE TYPE
+CREATE TYPE vdateadt;
+CREATE TYPE
+CREATE FUNCTION vdateadtin(cstring) RETURNS vdateadt as 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+psql:/tmp/TestVexecutor_vadt.sql:43: NOTICE: return type vdateadt is only a shell
+CREATE FUNCTION
+CREATE FUNCTION vdateadtout(vdateadt) RETURNS cstring AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+psql:/tmp/TestVexecutor_vadt.sql:44: NOTICE: argument type vdateadt is only a shell
+CREATE FUNCTION
+CREATE TYPE vdateadt ( INPUT = vdateadtin, OUTPUT = vdateadtout, element = date , storage=external);
+CREATE TYPE
+-- create operators for the vectorized types
+CREATE FUNCTION vint2vint2gt(vint2, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vint2, rightarg = vint2, procedure = vint2vint2gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vint2vint2ge(vint2, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vint2, rightarg = vint2, procedure = vint2vint2ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vint2vint2eq(vint2, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vint2, rightarg = vint2, procedure = vint2vint2eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vint2vint2ne(vint2, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vint2, rightarg = vint2, procedure = vint2vint2ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vint2vint2lt(vint2, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vint2, rightarg = vint2, procedure = vint2vint2lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vint2vint2le(vint2, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vint2, rightarg = vint2, procedure = vint2vint2le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vint2vint4gt(vint2, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vint2, rightarg = vint4, procedure = vint2vint4gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vint2vint4ge(vint2, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vint2, rightarg = vint4, procedure = vint2vint4ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vint2vint4eq(vint2, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vint2, rightarg = vint4, procedure = vint2vint4eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vint2vint4ne(vint2, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vint2, rightarg = vint4, procedure = vint2vint4ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vint2vint4lt(vint2, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vint2, rightarg = vint4, procedure = vint2vint4lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vint2vint4le(vint2, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vint2, rightarg = vint4, procedure = vint2vint4le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vint2vint8gt(vint2, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vint2, rightarg = vint8, procedure = vint2vint8gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vint2vint8ge(vint2, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vint2, rightarg = vint8, procedure = vint2vint8ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vint2vint8eq(vint2, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vint2, rightarg = vint8, procedure = vint2vint8eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vint2vint8ne(vint2, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vint2, rightarg = vint8, procedure = vint2vint8ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vint2vint8lt(vint2, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vint2, rightarg = vint8, procedure = vint2vint8lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vint2vint8le(vint2, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vint2, rightarg = vint8, procedure = vint2vint8le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vint2vfloat4gt(vint2, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vint2, rightarg = vfloat4, procedure = vint2vfloat4gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vint2vfloat4ge(vint2, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vint2, rightarg = vfloat4, procedure = vint2vfloat4ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vint2vfloat4eq(vint2, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vint2, rightarg = vfloat4, procedure = vint2vfloat4eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vint2vfloat4ne(vint2, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vint2, rightarg = vfloat4, procedure = vint2vfloat4ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vint2vfloat4lt(vint2, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vint2, rightarg = vfloat4, procedure = vint2vfloat4lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vint2vfloat4le(vint2, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vint2, rightarg = vfloat4, procedure = vint2vfloat4le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vint2vfloat8gt(vint2, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vint2, rightarg = vfloat8, procedure = vint2vfloat8gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vint2vfloat8ge(vint2, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vint2, rightarg = vfloat8, procedure = vint2vfloat8ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vint2vfloat8eq(vint2, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vint2, rightarg = vfloat8, procedure = vint2vfloat8eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vint2vfloat8ne(vint2, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vint2, rightarg = vfloat8, procedure = vint2vfloat8ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vint2vfloat8lt(vint2, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vint2, rightarg = vfloat8, procedure = vint2vfloat8lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vint2vfloat8le(vint2, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vint2, rightarg = vfloat8, procedure = vint2vfloat8le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vint2int2gt(vint2, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vint2, rightarg = int2, procedure = vint2int2gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vint2int2ge(vint2, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vint2, rightarg = int2, procedure = vint2int2ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vint2int2eq(vint2, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vint2, rightarg = int2, procedure = vint2int2eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vint2int2ne(vint2, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vint2, rightarg = int2, procedure = vint2int2ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vint2int2lt(vint2, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vint2, rightarg = int2, procedure = vint2int2lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vint2int2le(vint2, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vint2, rightarg = int2, procedure = vint2int2le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vint2int4gt(vint2, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vint2, rightarg = int4, procedure = vint2int4gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vint2int4ge(vint2, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vint2, rightarg = int4, procedure = vint2int4ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vint2int4eq(vint2, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vint2, rightarg = int4, procedure = vint2int4eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vint2int4ne(vint2, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vint2, rightarg = int4, procedure = vint2int4ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vint2int4lt(vint2, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vint2, rightarg = int4, procedure = vint2int4lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vint2int4le(vint2, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vint2, rightarg = int4, procedure = vint2int4le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vint2int8gt(vint2, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vint2, rightarg = int8, procedure = vint2int8gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vint2int8ge(vint2, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vint2, rightarg = int8, procedure = vint2int8ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vint2int8eq(vint2, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vint2, rightarg = int8, procedure = vint2int8eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vint2int8ne(vint2, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vint2, rightarg = int8, procedure = vint2int8ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vint2int8lt(vint2, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vint2, rightarg = int8, procedure = vint2int8lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vint2int8le(vint2, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vint2, rightarg = int8, procedure = vint2int8le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vint2float4gt(vint2, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vint2, rightarg = float4, procedure = vint2float4gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vint2float4ge(vint2, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vint2, rightarg = float4, procedure = vint2float4ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vint2float4eq(vint2, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vint2, rightarg = float4, procedure = vint2float4eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vint2float4ne(vint2, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vint2, rightarg = float4, procedure = vint2float4ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vint2float4lt(vint2, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vint2, rightarg = float4, procedure = vint2float4lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vint2float4le(vint2, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vint2, rightarg = float4, procedure = vint2float4le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vint2float8gt(vint2, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vint2, rightarg = float8, procedure = vint2float8gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vint2float8ge(vint2, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vint2, rightarg = float8, procedure = vint2float8ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vint2float8eq(vint2, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vint2, rightarg = float8, procedure = vint2float8eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vint2float8ne(vint2, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vint2, rightarg = float8, procedure = vint2float8ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vint2float8lt(vint2, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vint2, rightarg = float8, procedure = vint2float8lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vint2float8le(vint2, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vint2, rightarg = float8, procedure = vint2float8le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vint4vint2gt(vint4, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vint4, rightarg = vint2, procedure = vint4vint2gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vint4vint2ge(vint4, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vint4, rightarg = vint2, procedure = vint4vint2ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vint4vint2eq(vint4, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vint4, rightarg = vint2, procedure = vint4vint2eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vint4vint2ne(vint4, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vint4, rightarg = vint2, procedure = vint4vint2ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vint4vint2lt(vint4, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vint4, rightarg = vint2, procedure = vint4vint2lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vint4vint2le(vint4, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vint4, rightarg = vint2, procedure = vint4vint2le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vint4vint4gt(vint4, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vint4, rightarg = vint4, procedure = vint4vint4gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vint4vint4ge(vint4, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vint4, rightarg = vint4, procedure = vint4vint4ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vint4vint4eq(vint4, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vint4, rightarg = vint4, procedure = vint4vint4eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vint4vint4ne(vint4, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vint4, rightarg = vint4, procedure = vint4vint4ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vint4vint4lt(vint4, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vint4, rightarg = vint4, procedure = vint4vint4lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vint4vint4le(vint4, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vint4, rightarg = vint4, procedure = vint4vint4le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vint4vint8gt(vint4, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vint4, rightarg = vint8, procedure = vint4vint8gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vint4vint8ge(vint4, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vint4, rightarg = vint8, procedure = vint4vint8ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vint4vint8eq(vint4, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vint4, rightarg = vint8, procedure = vint4vint8eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vint4vint8ne(vint4, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vint4, rightarg = vint8, procedure = vint4vint8ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vint4vint8lt(vint4, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vint4, rightarg = vint8, procedure = vint4vint8lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vint4vint8le(vint4, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vint4, rightarg = vint8, procedure = vint4vint8le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vint4vfloat4gt(vint4, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vint4, rightarg = vfloat4, procedure = vint4vfloat4gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vint4vfloat4ge(vint4, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vint4, rightarg = vfloat4, procedure = vint4vfloat4ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vint4vfloat4eq(vint4, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vint4, rightarg = vfloat4, procedure = vint4vfloat4eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vint4vfloat4ne(vint4, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vint4, rightarg = vfloat4, procedure = vint4vfloat4ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vint4vfloat4lt(vint4, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vint4, rightarg = vfloat4, procedure = vint4vfloat4lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vint4vfloat4le(vint4, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vint4, rightarg = vfloat4, procedure = vint4vfloat4le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vint4vfloat8gt(vint4, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vint4, rightarg = vfloat8, procedure = vint4vfloat8gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vint4vfloat8ge(vint4, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vint4, rightarg = vfloat8, procedure = vint4vfloat8ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vint4vfloat8eq(vint4, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vint4, rightarg = vfloat8, procedure = vint4vfloat8eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vint4vfloat8ne(vint4, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vint4, rightarg = vfloat8, procedure = vint4vfloat8ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vint4vfloat8lt(vint4, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vint4, rightarg = vfloat8, procedure = vint4vfloat8lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vint4vfloat8le(vint4, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vint4, rightarg = vfloat8, procedure = vint4vfloat8le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vint4int2gt(vint4, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vint4, rightarg = int2, procedure = vint4int2gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vint4int2ge(vint4, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vint4, rightarg = int2, procedure = vint4int2ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vint4int2eq(vint4, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vint4, rightarg = int2, procedure = vint4int2eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vint4int2ne(vint4, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vint4, rightarg = int2, procedure = vint4int2ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vint4int2lt(vint4, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vint4, rightarg = int2, procedure = vint4int2lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vint4int2le(vint4, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vint4, rightarg = int2, procedure = vint4int2le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vint4int4gt(vint4, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vint4, rightarg = int4, procedure = vint4int4gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vint4int4ge(vint4, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vint4, rightarg = int4, procedure = vint4int4ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vint4int4eq(vint4, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vint4, rightarg = int4, procedure = vint4int4eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vint4int4ne(vint4, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vint4, rightarg = int4, procedure = vint4int4ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vint4int4lt(vint4, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vint4, rightarg = int4, procedure = vint4int4lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vint4int4le(vint4, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vint4, rightarg = int4, procedure = vint4int4le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vint4int8gt(vint4, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vint4, rightarg = int8, procedure = vint4int8gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vint4int8ge(vint4, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vint4, rightarg = int8, procedure = vint4int8ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vint4int8eq(vint4, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vint4, rightarg = int8, procedure = vint4int8eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vint4int8ne(vint4, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vint4, rightarg = int8, procedure = vint4int8ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vint4int8lt(vint4, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vint4, rightarg = int8, procedure = vint4int8lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vint4int8le(vint4, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vint4, rightarg = int8, procedure = vint4int8le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vint4float4gt(vint4, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vint4, rightarg = float4, procedure = vint4float4gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vint4float4ge(vint4, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vint4, rightarg = float4, procedure = vint4float4ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vint4float4eq(vint4, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vint4, rightarg = float4, procedure = vint4float4eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vint4float4ne(vint4, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vint4, rightarg = float4, procedure = vint4float4ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vint4float4lt(vint4, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vint4, rightarg = float4, procedure = vint4float4lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vint4float4le(vint4, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vint4, rightarg = float4, procedure = vint4float4le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vint4float8gt(vint4, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vint4, rightarg = float8, procedure = vint4float8gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vint4float8ge(vint4, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vint4, rightarg = float8, procedure = vint4float8ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vint4float8eq(vint4, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vint4, rightarg = float8, procedure = vint4float8eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vint4float8ne(vint4, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vint4, rightarg = float8, procedure = vint4float8ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vint4float8lt(vint4, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vint4, rightarg = float8, procedure = vint4float8lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vint4float8le(vint4, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vint4, rightarg = float8, procedure = vint4float8le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vint8vint2gt(vint8, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vint8, rightarg = vint2, procedure = vint8vint2gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vint8vint2ge(vint8, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vint8, rightarg = vint2, procedure = vint8vint2ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vint8vint2eq(vint8, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vint8, rightarg = vint2, procedure = vint8vint2eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vint8vint2ne(vint8, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vint8, rightarg = vint2, procedure = vint8vint2ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vint8vint2lt(vint8, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vint8, rightarg = vint2, procedure = vint8vint2lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vint8vint2le(vint8, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vint8, rightarg = vint2, procedure = vint8vint2le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vint8vint4gt(vint8, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vint8, rightarg = vint4, procedure = vint8vint4gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vint8vint4ge(vint8, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vint8, rightarg = vint4, procedure = vint8vint4ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vint8vint4eq(vint8, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vint8, rightarg = vint4, procedure = vint8vint4eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vint8vint4ne(vint8, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vint8, rightarg = vint4, procedure = vint8vint4ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vint8vint4lt(vint8, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vint8, rightarg = vint4, procedure = vint8vint4lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vint8vint4le(vint8, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vint8, rightarg = vint4, procedure = vint8vint4le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vint8vint8gt(vint8, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vint8, rightarg = vint8, procedure = vint8vint8gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vint8vint8ge(vint8, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vint8, rightarg = vint8, procedure = vint8vint8ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vint8vint8eq(vint8, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vint8, rightarg = vint8, procedure = vint8vint8eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vint8vint8ne(vint8, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vint8, rightarg = vint8, procedure = vint8vint8ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vint8vint8lt(vint8, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vint8, rightarg = vint8, procedure = vint8vint8lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vint8vint8le(vint8, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vint8, rightarg = vint8, procedure = vint8vint8le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vint8vfloat4gt(vint8, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vint8, rightarg = vfloat4, procedure = vint8vfloat4gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vint8vfloat4ge(vint8, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vint8, rightarg = vfloat4, procedure = vint8vfloat4ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vint8vfloat4eq(vint8, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vint8, rightarg = vfloat4, procedure = vint8vfloat4eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vint8vfloat4ne(vint8, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vint8, rightarg = vfloat4, procedure = vint8vfloat4ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vint8vfloat4lt(vint8, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vint8, rightarg = vfloat4, procedure = vint8vfloat4lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vint8vfloat4le(vint8, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vint8, rightarg = vfloat4, procedure = vint8vfloat4le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vint8vfloat8gt(vint8, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vint8, rightarg = vfloat8, procedure = vint8vfloat8gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vint8vfloat8ge(vint8, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vint8, rightarg = vfloat8, procedure = vint8vfloat8ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vint8vfloat8eq(vint8, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vint8, rightarg = vfloat8, procedure = vint8vfloat8eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vint8vfloat8ne(vint8, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vint8, rightarg = vfloat8, procedure = vint8vfloat8ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vint8vfloat8lt(vint8, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vint8, rightarg = vfloat8, procedure = vint8vfloat8lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vint8vfloat8le(vint8, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vint8, rightarg = vfloat8, procedure = vint8vfloat8le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vint8int2gt(vint8, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vint8, rightarg = int2, procedure = vint8int2gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vint8int2ge(vint8, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vint8, rightarg = int2, procedure = vint8int2ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vint8int2eq(vint8, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vint8, rightarg = int2, procedure = vint8int2eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vint8int2ne(vint8, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vint8, rightarg = int2, procedure = vint8int2ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vint8int2lt(vint8, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vint8, rightarg = int2, procedure = vint8int2lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vint8int2le(vint8, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vint8, rightarg = int2, procedure = vint8int2le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vint8int4gt(vint8, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vint8, rightarg = int4, procedure = vint8int4gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vint8int4ge(vint8, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vint8, rightarg = int4, procedure = vint8int4ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vint8int4eq(vint8, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vint8, rightarg = int4, procedure = vint8int4eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vint8int4ne(vint8, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vint8, rightarg = int4, procedure = vint8int4ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vint8int4lt(vint8, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vint8, rightarg = int4, procedure = vint8int4lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vint8int4le(vint8, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vint8, rightarg = int4, procedure = vint8int4le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vint8int8gt(vint8, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vint8, rightarg = int8, procedure = vint8int8gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vint8int8ge(vint8, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vint8, rightarg = int8, procedure = vint8int8ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vint8int8eq(vint8, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vint8, rightarg = int8, procedure = vint8int8eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vint8int8ne(vint8, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vint8, rightarg = int8, procedure = vint8int8ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vint8int8lt(vint8, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vint8, rightarg = int8, procedure = vint8int8lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vint8int8le(vint8, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vint8, rightarg = int8, procedure = vint8int8le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vint8float4gt(vint8, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vint8, rightarg = float4, procedure = vint8float4gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vint8float4ge(vint8, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vint8, rightarg = float4, procedure = vint8float4ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vint8float4eq(vint8, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vint8, rightarg = float4, procedure = vint8float4eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vint8float4ne(vint8, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vint8, rightarg = float4, procedure = vint8float4ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vint8float4lt(vint8, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vint8, rightarg = float4, procedure = vint8float4lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vint8float4le(vint8, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vint8, rightarg = float4, procedure = vint8float4le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vint8float8gt(vint8, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vint8, rightarg = float8, procedure = vint8float8gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vint8float8ge(vint8, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vint8, rightarg = float8, procedure = vint8float8ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vint8float8eq(vint8, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vint8, rightarg = float8, procedure = vint8float8eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vint8float8ne(vint8, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vint8, rightarg = float8, procedure = vint8float8ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vint8float8lt(vint8, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vint8, rightarg = float8, procedure = vint8float8lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vint8float8le(vint8, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vint8, rightarg = float8, procedure = vint8float8le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4vint2gt(vfloat4, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vfloat4, rightarg = vint2, procedure = vfloat4vint2gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4vint2ge(vfloat4, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vfloat4, rightarg = vint2, procedure = vfloat4vint2ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4vint2eq(vfloat4, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vfloat4, rightarg = vint2, procedure = vfloat4vint2eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4vint2ne(vfloat4, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vfloat4, rightarg = vint2, procedure = vfloat4vint2ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4vint2lt(vfloat4, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vfloat4, rightarg = vint2, procedure = vfloat4vint2lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4vint2le(vfloat4, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vfloat4, rightarg = vint2, procedure = vfloat4vint2le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4vint4gt(vfloat4, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vfloat4, rightarg = vint4, procedure = vfloat4vint4gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4vint4ge(vfloat4, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vfloat4, rightarg = vint4, procedure = vfloat4vint4ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4vint4eq(vfloat4, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vfloat4, rightarg = vint4, procedure = vfloat4vint4eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4vint4ne(vfloat4, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vfloat4, rightarg = vint4, procedure = vfloat4vint4ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4vint4lt(vfloat4, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vfloat4, rightarg = vint4, procedure = vfloat4vint4lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4vint4le(vfloat4, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vfloat4, rightarg = vint4, procedure = vfloat4vint4le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4vint8gt(vfloat4, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vfloat4, rightarg = vint8, procedure = vfloat4vint8gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4vint8ge(vfloat4, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vfloat4, rightarg = vint8, procedure = vfloat4vint8ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4vint8eq(vfloat4, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vfloat4, rightarg = vint8, procedure = vfloat4vint8eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4vint8ne(vfloat4, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vfloat4, rightarg = vint8, procedure = vfloat4vint8ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4vint8lt(vfloat4, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vfloat4, rightarg = vint8, procedure = vfloat4vint8lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4vint8le(vfloat4, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vfloat4, rightarg = vint8, procedure = vfloat4vint8le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4vfloat4gt(vfloat4, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vfloat4, rightarg = vfloat4, procedure = vfloat4vfloat4gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4vfloat4ge(vfloat4, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vfloat4, rightarg = vfloat4, procedure = vfloat4vfloat4ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4vfloat4eq(vfloat4, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vfloat4, rightarg = vfloat4, procedure = vfloat4vfloat4eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4vfloat4ne(vfloat4, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vfloat4, rightarg = vfloat4, procedure = vfloat4vfloat4ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4vfloat4lt(vfloat4, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vfloat4, rightarg = vfloat4, procedure = vfloat4vfloat4lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4vfloat4le(vfloat4, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vfloat4, rightarg = vfloat4, procedure = vfloat4vfloat4le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4vfloat8gt(vfloat4, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vfloat4, rightarg = vfloat8, procedure = vfloat4vfloat8gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4vfloat8ge(vfloat4, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vfloat4, rightarg = vfloat8, procedure = vfloat4vfloat8ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4vfloat8eq(vfloat4, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vfloat4, rightarg = vfloat8, procedure = vfloat4vfloat8eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4vfloat8ne(vfloat4, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vfloat4, rightarg = vfloat8, procedure = vfloat4vfloat8ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4vfloat8lt(vfloat4, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vfloat4, rightarg = vfloat8, procedure = vfloat4vfloat8lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4vfloat8le(vfloat4, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vfloat4, rightarg = vfloat8, procedure = vfloat4vfloat8le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4int2gt(vfloat4, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vfloat4, rightarg = int2, procedure = vfloat4int2gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4int2ge(vfloat4, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vfloat4, rightarg = int2, procedure = vfloat4int2ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4int2eq(vfloat4, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vfloat4, rightarg = int2, procedure = vfloat4int2eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4int2ne(vfloat4, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vfloat4, rightarg = int2, procedure = vfloat4int2ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4int2lt(vfloat4, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vfloat4, rightarg = int2, procedure = vfloat4int2lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4int2le(vfloat4, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vfloat4, rightarg = int2, procedure = vfloat4int2le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4int4gt(vfloat4, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vfloat4, rightarg = int4, procedure = vfloat4int4gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4int4ge(vfloat4, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vfloat4, rightarg = int4, procedure = vfloat4int4ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4int4eq(vfloat4, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vfloat4, rightarg = int4, procedure = vfloat4int4eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4int4ne(vfloat4, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vfloat4, rightarg = int4, procedure = vfloat4int4ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4int4lt(vfloat4, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vfloat4, rightarg = int4, procedure = vfloat4int4lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4int4le(vfloat4, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vfloat4, rightarg = int4, procedure = vfloat4int4le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4int8gt(vfloat4, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vfloat4, rightarg = int8, procedure = vfloat4int8gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4int8ge(vfloat4, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vfloat4, rightarg = int8, procedure = vfloat4int8ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4int8eq(vfloat4, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vfloat4, rightarg = int8, procedure = vfloat4int8eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4int8ne(vfloat4, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vfloat4, rightarg = int8, procedure = vfloat4int8ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4int8lt(vfloat4, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vfloat4, rightarg = int8, procedure = vfloat4int8lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4int8le(vfloat4, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vfloat4, rightarg = int8, procedure = vfloat4int8le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4float4gt(vfloat4, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vfloat4, rightarg = float4, procedure = vfloat4float4gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4float4ge(vfloat4, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vfloat4, rightarg = float4, procedure = vfloat4float4ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4float4eq(vfloat4, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vfloat4, rightarg = float4, procedure = vfloat4float4eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4float4ne(vfloat4, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vfloat4, rightarg = float4, procedure = vfloat4float4ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4float4lt(vfloat4, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vfloat4, rightarg = float4, procedure = vfloat4float4lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4float4le(vfloat4, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vfloat4, rightarg = float4, procedure = vfloat4float4le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4float8gt(vfloat4, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vfloat4, rightarg = float8, procedure = vfloat4float8gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4float8ge(vfloat4, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vfloat4, rightarg = float8, procedure = vfloat4float8ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4float8eq(vfloat4, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vfloat4, rightarg = float8, procedure = vfloat4float8eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4float8ne(vfloat4, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vfloat4, rightarg = float8, procedure = vfloat4float8ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4float8lt(vfloat4, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vfloat4, rightarg = float8, procedure = vfloat4float8lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4float8le(vfloat4, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vfloat4, rightarg = float8, procedure = vfloat4float8le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8vint2gt(vfloat8, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vfloat8, rightarg = vint2, procedure = vfloat8vint2gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8vint2ge(vfloat8, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vfloat8, rightarg = vint2, procedure = vfloat8vint2ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8vint2eq(vfloat8, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vfloat8, rightarg = vint2, procedure = vfloat8vint2eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8vint2ne(vfloat8, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vfloat8, rightarg = vint2, procedure = vfloat8vint2ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8vint2lt(vfloat8, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vfloat8, rightarg = vint2, procedure = vfloat8vint2lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8vint2le(vfloat8, vint2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vfloat8, rightarg = vint2, procedure = vfloat8vint2le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8vint4gt(vfloat8, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vfloat8, rightarg = vint4, procedure = vfloat8vint4gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8vint4ge(vfloat8, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vfloat8, rightarg = vint4, procedure = vfloat8vint4ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8vint4eq(vfloat8, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vfloat8, rightarg = vint4, procedure = vfloat8vint4eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8vint4ne(vfloat8, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vfloat8, rightarg = vint4, procedure = vfloat8vint4ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8vint4lt(vfloat8, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vfloat8, rightarg = vint4, procedure = vfloat8vint4lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8vint4le(vfloat8, vint4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vfloat8, rightarg = vint4, procedure = vfloat8vint4le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8vint8gt(vfloat8, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vfloat8, rightarg = vint8, procedure = vfloat8vint8gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8vint8ge(vfloat8, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vfloat8, rightarg = vint8, procedure = vfloat8vint8ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8vint8eq(vfloat8, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vfloat8, rightarg = vint8, procedure = vfloat8vint8eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8vint8ne(vfloat8, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vfloat8, rightarg = vint8, procedure = vfloat8vint8ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8vint8lt(vfloat8, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vfloat8, rightarg = vint8, procedure = vfloat8vint8lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8vint8le(vfloat8, vint8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vfloat8, rightarg = vint8, procedure = vfloat8vint8le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8vfloat4gt(vfloat8, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vfloat8, rightarg = vfloat4, procedure = vfloat8vfloat4gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8vfloat4ge(vfloat8, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vfloat8, rightarg = vfloat4, procedure = vfloat8vfloat4ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8vfloat4eq(vfloat8, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vfloat8, rightarg = vfloat4, procedure = vfloat8vfloat4eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8vfloat4ne(vfloat8, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vfloat8, rightarg = vfloat4, procedure = vfloat8vfloat4ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8vfloat4lt(vfloat8, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vfloat8, rightarg = vfloat4, procedure = vfloat8vfloat4lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8vfloat4le(vfloat8, vfloat4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vfloat8, rightarg = vfloat4, procedure = vfloat8vfloat4le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8vfloat8gt(vfloat8, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vfloat8, rightarg = vfloat8, procedure = vfloat8vfloat8gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8vfloat8ge(vfloat8, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vfloat8, rightarg = vfloat8, procedure = vfloat8vfloat8ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8vfloat8eq(vfloat8, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vfloat8, rightarg = vfloat8, procedure = vfloat8vfloat8eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8vfloat8ne(vfloat8, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vfloat8, rightarg = vfloat8, procedure = vfloat8vfloat8ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8vfloat8lt(vfloat8, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vfloat8, rightarg = vfloat8, procedure = vfloat8vfloat8lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8vfloat8le(vfloat8, vfloat8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vfloat8, rightarg = vfloat8, procedure = vfloat8vfloat8le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8int2gt(vfloat8, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vfloat8, rightarg = int2, procedure = vfloat8int2gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8int2ge(vfloat8, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vfloat8, rightarg = int2, procedure = vfloat8int2ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8int2eq(vfloat8, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vfloat8, rightarg = int2, procedure = vfloat8int2eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8int2ne(vfloat8, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vfloat8, rightarg = int2, procedure = vfloat8int2ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8int2lt(vfloat8, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vfloat8, rightarg = int2, procedure = vfloat8int2lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8int2le(vfloat8, int2) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vfloat8, rightarg = int2, procedure = vfloat8int2le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8int4gt(vfloat8, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vfloat8, rightarg = int4, procedure = vfloat8int4gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8int4ge(vfloat8, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vfloat8, rightarg = int4, procedure = vfloat8int4ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8int4eq(vfloat8, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vfloat8, rightarg = int4, procedure = vfloat8int4eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8int4ne(vfloat8, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vfloat8, rightarg = int4, procedure = vfloat8int4ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8int4lt(vfloat8, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vfloat8, rightarg = int4, procedure = vfloat8int4lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8int4le(vfloat8, int4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vfloat8, rightarg = int4, procedure = vfloat8int4le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8int8gt(vfloat8, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vfloat8, rightarg = int8, procedure = vfloat8int8gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8int8ge(vfloat8, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vfloat8, rightarg = int8, procedure = vfloat8int8ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8int8eq(vfloat8, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vfloat8, rightarg = int8, procedure = vfloat8int8eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8int8ne(vfloat8, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vfloat8, rightarg = int8, procedure = vfloat8int8ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8int8lt(vfloat8, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vfloat8, rightarg = int8, procedure = vfloat8int8lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8int8le(vfloat8, int8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vfloat8, rightarg = int8, procedure = vfloat8int8le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8float4gt(vfloat8, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vfloat8, rightarg = float4, procedure = vfloat8float4gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8float4ge(vfloat8, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vfloat8, rightarg = float4, procedure = vfloat8float4ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8float4eq(vfloat8, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vfloat8, rightarg = float4, procedure = vfloat8float4eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8float4ne(vfloat8, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vfloat8, rightarg = float4, procedure = vfloat8float4ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8float4lt(vfloat8, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vfloat8, rightarg = float4, procedure = vfloat8float4lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8float4le(vfloat8, float4) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vfloat8, rightarg = float4, procedure = vfloat8float4le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8float8gt(vfloat8, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR > ( leftarg = vfloat8, rightarg = float8, procedure = vfloat8float8gt, commutator = <= );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8float8ge(vfloat8, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR >= ( leftarg = vfloat8, rightarg = float8, procedure = vfloat8float8ge, commutator = < );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8float8eq(vfloat8, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR = ( leftarg = vfloat8, rightarg = float8, procedure = vfloat8float8eq, commutator = <> );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8float8ne(vfloat8, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <> ( leftarg = vfloat8, rightarg = float8, procedure = vfloat8float8ne, commutator = = );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8float8lt(vfloat8, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR < ( leftarg = vfloat8, rightarg = float8, procedure = vfloat8float8lt, commutator = >= );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8float8le(vfloat8, float8) RETURNS vbool AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR <= ( leftarg = vfloat8, rightarg = float8, procedure = vfloat8float8le, commutator = > );
+CREATE OPERATOR
+CREATE FUNCTION vint2vint2pl(vint2, vint2) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR + ( leftarg = vint2, rightarg = vint2, procedure = vint2vint2pl, commutator = - );
+CREATE OPERATOR
+CREATE FUNCTION vint2vint2mi(vint2, vint2) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR - ( leftarg = vint2, rightarg = vint2, procedure = vint2vint2mi, commutator = + );
+CREATE OPERATOR
+CREATE FUNCTION vint2vint2mul(vint2, vint2) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR * ( leftarg = vint2, rightarg = vint2, procedure = vint2vint2mul, commutator = / );
+CREATE OPERATOR
+CREATE FUNCTION vint2vint2div(vint2, vint2) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR / ( leftarg = vint2, rightarg = vint2, procedure = vint2vint2div, commutator = * );
+CREATE OPERATOR
+CREATE FUNCTION vint4vint4pl(vint4, vint4) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR + ( leftarg = vint4, rightarg = vint4, procedure = vint4vint4pl, commutator = - );
+CREATE OPERATOR
+CREATE FUNCTION vint4vint4mi(vint4, vint4) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR - ( leftarg = vint4, rightarg = vint4, procedure = vint4vint4mi, commutator = + );
+CREATE OPERATOR
+CREATE FUNCTION vint4vint4mul(vint4, vint4) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR * ( leftarg = vint4, rightarg = vint4, procedure = vint4vint4mul, commutator = / );
+CREATE OPERATOR
+CREATE FUNCTION vint4vint4div(vint4, vint4) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR / ( leftarg = vint4, rightarg = vint4, procedure = vint4vint4div, commutator = * );
+CREATE OPERATOR
+CREATE FUNCTION vint8vint8pl(vint8, vint8) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR + ( leftarg = vint8, rightarg = vint8, procedure = vint8vint8pl, commutator = - );
+CREATE OPERATOR
+CREATE FUNCTION vint8vint8mi(vint8, vint8) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR - ( leftarg = vint8, rightarg = vint8, procedure = vint8vint8mi, commutator = + );
+CREATE OPERATOR
+CREATE FUNCTION vint8vint8mul(vint8, vint8) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR * ( leftarg = vint8, rightarg = vint8, procedure = vint8vint8mul, commutator = / );
+CREATE OPERATOR
+CREATE FUNCTION vint8vint8div(vint8, vint8) RETURNS vint8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR / ( leftarg = vint8, rightarg = vint8, procedure = vint8vint8div, commutator = * );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4vfloat4pl(vfloat4, vfloat4) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR + ( leftarg = vfloat4, rightarg = vfloat4, procedure = vfloat4vfloat4pl, commutator = - );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4vfloat4mi(vfloat4, vfloat4) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR - ( leftarg = vfloat4, rightarg = vfloat4, procedure = vfloat4vfloat4mi, commutator = + );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4vfloat4mul(vfloat4, vfloat4) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR * ( leftarg = vfloat4, rightarg = vfloat4, procedure = vfloat4vfloat4mul, commutator = / );
+CREATE OPERATOR
+CREATE FUNCTION vfloat4vfloat4div(vfloat4, vfloat4) RETURNS vfloat4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR / ( leftarg = vfloat4, rightarg = vfloat4, procedure = vfloat4vfloat4div, commutator = * );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8vfloat8pl(vfloat8, vfloat8) RETURNS vfloat8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR + ( leftarg = vfloat8, rightarg = vfloat8, procedure = vfloat8vfloat8pl, commutator = - );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8vfloat8mi(vfloat8, vfloat8) RETURNS vfloat8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR - ( leftarg = vfloat8, rightarg = vfloat8, procedure = vfloat8vfloat8mi, commutator = + );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8vfloat8mul(vfloat8, vfloat8) RETURNS vfloat8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR * ( leftarg = vfloat8, rightarg = vfloat8, procedure = vfloat8vfloat8mul, commutator = / );
+CREATE OPERATOR
+CREATE FUNCTION vfloat8vfloat8div(vfloat8, vfloat8) RETURNS vfloat8 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR / ( leftarg = vfloat8, rightarg = vfloat8, procedure = vfloat8vfloat8div, commutator = * );
+CREATE OPERATOR
+CREATE FUNCTION vint2int2pl(vint2, int2) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR + ( leftarg = vint2, rightarg = int2, procedure = vint2int2pl, commutator = - );
+CREATE OPERATOR
+CREATE FUNCTION vint2int2mi(vint2, int2) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR - ( leftarg = vint2, rightarg = int2, procedure = vint2int2mi, commutator = + );
+CREATE OPERATOR
+CREATE FUNCTION vint2int2mul(vint2, int2) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR * ( leftarg = vint2, rightarg = int2, procedure = vint2int2mul, commutator = / );
+CREATE OPERATOR
+CREATE FUNCTION vint2int2div(vint2, int2) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR / ( leftarg = vint2, rightarg = int2, procedure = vint2int2div, commutator = * );
+CREATE OPERATOR
+CREATE FUNCTION vint2int4pl(vint2, int4) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR + ( leftarg = vint2, rightarg = int4, procedure = vint2int4pl, commutator = - );
+CREATE OPERATOR
+CREATE FUNCTION vint2int4mi(vint2, int4) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR - ( leftarg = vint2, rightarg = int4, procedure = vint2int4mi, commutator = + );
+CREATE OPERATOR
+CREATE FUNCTION vint2int4mul(vint2, int4) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR * ( leftarg = vint2, rightarg = int4, procedure = vint2int4mul, commutator = / );
+CREATE OPERATOR
+CREATE FUNCTION vint2int4div(vint2, int4) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR / ( leftarg = vint2, rightarg = int4, procedure = vint2int4div, commutator = * );
+CREATE OPERATOR
+CREATE FUNCTION vint2int8pl(vint2, int8) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR + ( leftarg = vint2, rightarg = int8, procedure = vint2int8pl, commutator = - );
+CREATE OPERATOR
+CREATE FUNCTION vint2int8mi(vint2, int8) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR - ( leftarg = vint2, rightarg = int8, procedure = vint2int8mi, commutator = + );
+CREATE OPERATOR
+CREATE FUNCTION vint2int8mul(vint2, int8) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR * ( leftarg = vint2, rightarg = int8, procedure = vint2int8mul, commutator = / );
+CREATE OPERATOR
+CREATE FUNCTION vint2int8div(vint2, int8) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR / ( leftarg = vint2, rightarg = int8, procedure = vint2int8div, commutator = * );
+CREATE OPERATOR
+CREATE FUNCTION vint2float4pl(vint2, float4) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR + ( leftarg = vint2, rightarg = float4, procedure = vint2float4pl, commutator = - );
+CREATE OPERATOR
+CREATE FUNCTION vint2float4mi(vint2, float4) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR - ( leftarg = vint2, rightarg = float4, procedure = vint2float4mi, commutator = + );
+CREATE OPERATOR
+CREATE FUNCTION vint2float4mul(vint2, float4) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR * ( leftarg = vint2, rightarg = float4, procedure = vint2float4mul, commutator = / );
+CREATE OPERATOR
+CREATE FUNCTION vint2float4div(vint2, float4) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR / ( leftarg = vint2, rightarg = float4, procedure = vint2float4div, commutator = * );
+CREATE OPERATOR
+CREATE FUNCTION vint2float8pl(vint2, float8) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR + ( leftarg = vint2, rightarg = float8, procedure = vint2float8pl, commutator = - );
+CREATE OPERATOR
+CREATE FUNCTION vint2float8mi(vint2, float8) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR - ( leftarg = vint2, rightarg = float8, procedure = vint2float8mi, commutator = + );
+CREATE OPERATOR
+CREATE FUNCTION vint2float8mul(vint2, float8) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR * ( leftarg = vint2, rightarg = float8, procedure = vint2float8mul, commutator = / );
+CREATE OPERATOR
+CREATE FUNCTION vint2float8div(vint2, float8) RETURNS vint2 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR / ( leftarg = vint2, rightarg = float8, procedure = vint2float8div, commutator = * );
+CREATE OPERATOR
+CREATE FUNCTION vint4int2pl(vint4, int2) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR + ( leftarg = vint4, rightarg = int2, procedure = vint4int2pl, commutator = - );
+CREATE OPERATOR
+CREATE FUNCTION vint4int2mi(vint4, int2) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR - ( leftarg = vint4, rightarg = int2, procedure = vint4int2mi, commutator = + );
+CREATE OPERATOR
+CREATE FUNCTION vint4int2mul(vint4, int2) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR * ( leftarg = vint4, rightarg = int2, procedure = vint4int2mul, commutator = / );
+CREATE OPERATOR
+CREATE FUNCTION vint4int2div(vint4, int2) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR / ( leftarg = vint4, rightarg = int2, procedure = vint4int2div, commutator = * );
+CREATE OPERATOR
+CREATE FUNCTION vint4int4pl(vint4, int4) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR + ( leftarg = vint4, rightarg = int4, procedure = vint4int4pl, commutator = - );
+CREATE OPERATOR
+CREATE FUNCTION vint4int4mi(vint4, int4) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR - ( leftarg = vint4, rightarg = int4, procedure = vint4int4mi, commutator = + );
+CREATE OPERATOR
+CREATE FUNCTION vint4int4mul(vint4, int4) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR * ( leftarg = vint4, rightarg = int4, procedure = vint4int4mul, commutator = / );
+CREATE OPERATOR
+CREATE FUNCTION vint4int4div(vint4, int4) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR / ( leftarg = vint4, rightarg = int4, procedure = vint4int4div, commutator = * );
+CREATE OPERATOR
+CREATE FUNCTION vint4int8pl(vint4, int8) RETURNS vint4 AS 'vexecutor.so' LANGUAGE C IMMUTABLE STRICT;
+CREATE FUNCTION
+CREATE OPERATOR + ( leftarg = vint4, rightarg = int8, procedure = vin
<TRUNCATED>
[9/9] incubator-hawq git commit: HAWQ-1612. Implement vectorized
aggregate functions, such as avg/sum/count.
Posted by rl...@apache.org.
HAWQ-1612. Implement vectorized aggregate functions, such as avg/sum/count.
Project: http://git-wip-us.apache.org/repos/asf/incubator-hawq/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-hawq/commit/ce2814d4
Tree: http://git-wip-us.apache.org/repos/asf/incubator-hawq/tree/ce2814d4
Diff: http://git-wip-us.apache.org/repos/asf/incubator-hawq/diff/ce2814d4
Branch: refs/heads/master
Commit: ce2814d4e2912d5fae8b71b6b488526858c6fb08
Parents: 25ed0ae
Author: Shujie Zhang <sh...@pivotal.io>
Authored: Tue May 15 12:39:04 2018 +0800
Committer: rlei <rl...@pivotal.io>
Committed: Fri May 18 17:50:58 2018 +0800
----------------------------------------------------------------------
contrib/vexecutor/Makefile | 3 +-
contrib/vexecutor/README | 31 +-
contrib/vexecutor/ao_reader.c | 9 +
contrib/vexecutor/clean_type.sql | 7 -
contrib/vexecutor/clean_udv.sql | 49 +
contrib/vexecutor/create_type.sql | 960 -----
contrib/vexecutor/create_udv.sql | 1139 +++++
contrib/vexecutor/execVScan.c | 5 +-
contrib/vexecutor/vagg.c | 2236 ++++++++++
contrib/vexecutor/vagg.h | 92 +
contrib/vexecutor/vcheck.c | 172 +-
contrib/vexecutor/vcheck.h | 9 +
contrib/vexecutor/vexecutor.c | 178 +-
contrib/vexecutor/vexecutor.h | 2 +
contrib/vexecutor/vtype.c | 46 +-
contrib/vexecutor/vtype.h | 27 +-
src/backend/executor/execHHashagg.c | 24 +-
src/backend/executor/execProcnode.c | 1 +
src/backend/executor/nodeAgg.c | 15 +-
src/include/executor/execHHashagg.h | 19 +
src/include/executor/nodeAgg.h | 7 +
src/include/executor/nodeMotion.h | 1 -
.../feature/vexecutor/ans/create_type_vadt.ans | 2014 +++++++++
src/test/feature/vexecutor/ans/drop_type.ans | 2342 +++++-----
src/test/feature/vexecutor/ans/vagg.ans | 1672 ++++++++
src/test/feature/vexecutor/ans/vdate.ans | 4027 +++++++++---------
src/test/feature/vexecutor/sql/create_type.sql | 181 +-
src/test/feature/vexecutor/sql/drop_type.sql | 44 +-
src/test/feature/vexecutor/sql/vagg.sql | 301 ++
src/test/feature/vexecutor/test_vexecutor.cpp | 150 +-
30 files changed, 11503 insertions(+), 4260 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/ce2814d4/contrib/vexecutor/Makefile
----------------------------------------------------------------------
diff --git a/contrib/vexecutor/Makefile b/contrib/vexecutor/Makefile
index da0ae51..5b9abec 100644
--- a/contrib/vexecutor/Makefile
+++ b/contrib/vexecutor/Makefile
@@ -26,7 +26,8 @@ OBJS = vexecutor.o \
parquet_reader.o \
ao_reader.o \
nodeVMotion.o \
- vtype_ext.o
+ vtype_ext.o \
+ vagg.o
PG_CXXFLAGS = -Wall -O0 -g -std=c++11
PG_LIBS = $(libpq_pgport)
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/ce2814d4/contrib/vexecutor/README
----------------------------------------------------------------------
diff --git a/contrib/vexecutor/README b/contrib/vexecutor/README
index 68f9e92..34e8920 100644
--- a/contrib/vexecutor/README
+++ b/contrib/vexecutor/README
@@ -34,16 +34,18 @@ Build HAWQ Vectorized Executor steps
to activate vectorized execution
-How to add the default vectorized data types
----------------------------------------------
+How to add the default vectorized data types and aggregate
+functions
+----------------------------------------------------------
1. Follow "Build HAWQ Vectorized Executor steps" to start HAWQ.
-2. execute "create_type.sql" in psql. then some vectorized
- data types will be add to HAWQ.
+2. execute "create_udv.sql" in psql. then some vectorized
+ data types and vectorized aggregate functions will be
+ add to HAWQ.
-3. If the default vectorized is no use, you can delete then by
- executing "drop_types.sql" in psql.
+3. If the default vectorized is no use, you can delete them by
+ executing "clean_udv.sql" in psql.
How to add an new vectorized data types and operators
@@ -71,12 +73,17 @@ For example, If the base type is 'XXX', we want to create the
vectorized data types for it:
1) You can add the vectorized data types struct
(e.g. Add to vtype.h)
- typedef struct vXXX
- {
- vheader header;
- XXX values[0];
- }vXXX;
-
+ typedef struct vtype {
+ int _vl_len;
+ Oid elemtype;
+ int dim;
+ bool *isnull;
+ bool *skipref;
+ Datum values[0];
+ }vtype;
+
+ typedef struct vtype vXXX;
+
Implement the new IN/OUT functions for this data type:
Datum vXXXin(PG_FUNCTION_ARGS);
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/ce2814d4/contrib/vexecutor/ao_reader.c
----------------------------------------------------------------------
diff --git a/contrib/vexecutor/ao_reader.c b/contrib/vexecutor/ao_reader.c
index 44ad709..77e6984 100644
--- a/contrib/vexecutor/ao_reader.c
+++ b/contrib/vexecutor/ao_reader.c
@@ -108,6 +108,15 @@ AppendOnlyVScanNext(ScanState *scanState)
if(!slot)
slot = scanState->ss_ScanTupleSlot;
+ for(int i = 0;i < tb->ncols ; i ++)
+ {
+ if(vs->ao->proj[i])
+ {
+ if(tb->datagroup[i])
+ tb->datagroup[i]->dim = tb->nrows;
+ }
+ }
+
if (tb->nrows == 0)
ExecClearTuple(slot);
else
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/ce2814d4/contrib/vexecutor/clean_type.sql
----------------------------------------------------------------------
diff --git a/contrib/vexecutor/clean_type.sql b/contrib/vexecutor/clean_type.sql
deleted file mode 100644
index dfaf755..0000000
--- a/contrib/vexecutor/clean_type.sql
+++ /dev/null
@@ -1,7 +0,0 @@
-
-drop type vint2 cascade;
-drop type vint4 cascade;
-drop type vint8 cascade;
-drop type vfloat8 cascade;
-drop type vfloat4 cascade;
-drop type vbool cascade;
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/ce2814d4/contrib/vexecutor/clean_udv.sql
----------------------------------------------------------------------
diff --git a/contrib/vexecutor/clean_udv.sql b/contrib/vexecutor/clean_udv.sql
new file mode 100644
index 0000000..1cee20f
--- /dev/null
+++ b/contrib/vexecutor/clean_udv.sql
@@ -0,0 +1,49 @@
+--drop agg functions
+--drop the previous funcitons
+DROP AGGREGATE IF EXISTS sum(vint2);
+DROP AGGREGATE IF EXISTS sum(vint4);
+DROP AGGREGATE IF EXISTS sum(vint8);
+DROP AGGREGATE IF EXISTS sum(vfloat4);
+DROP AGGREGATE IF EXISTS sum(vfloat8);
+
+DROP AGGREGATE IF EXISTS avg(vint2);
+DROP AGGREGATE IF EXISTS avg(vint4);
+DROP AGGREGATE IF EXISTS avg(vint8);
+DROP AGGREGATE IF EXISTS avg(vfloat4);
+DROP AGGREGATE IF EXISTS avg(vfloat8);
+
+DROP AGGREGATE IF EXISTS count(vint2);
+DROP AGGREGATE IF EXISTS count(vint4);
+DROP AGGREGATE IF EXISTS count(vint8);
+DROP AGGREGATE IF EXISTS count(vfloat4);
+DROP AGGREGATE IF EXISTS count(vfloat8);
+
+DROP AGGREGATE IF EXISTS veccount(*);
+
+DROP FUNCTION IF EXISTS vint2_accum(int8, vint2);
+DROP FUNCTION IF EXISTS vint4_accum(int8, vint4);
+DROP FUNCTION IF EXISTS vint8_accum(numeric, vint8);
+DROP FUNCTION IF EXISTS vfloat4_accum(float4, vfloat4);
+DROP FUNCTION IF EXISTS vfloat8_accum(float8, vfloat8);
+
+DROP FUNCTION IF EXISTS vint2_avg_accum(bytea, vint2);
+DROP FUNCTION IF EXISTS vint4_avg_accum(bytea, vint4);
+DROP FUNCTION IF EXISTS vint8_avg_accum(bytea, vint8);
+DROP FUNCTION IF EXISTS vfloat4_avg_accum(bytea, vfloat4);
+DROP FUNCTION IF EXISTS vfloat8_avg_accum(bytea, vfloat8);
+
+DROP FUNCTION IF EXISTS vint2_inc(int8, vint2);
+DROP FUNCTION IF EXISTS vint4_inc(int8, vint4);
+DROP FUNCTION IF EXISTS vint8_inc(int8, vint8);
+DROP FUNCTION IF EXISTS vfloat4_inc(int8, vfloat4);
+DROP FUNCTION IF EXISTS vfloat8_inc(int8, vfloat8);
+
+DROP FUNCTION IF EXISTS vec_inc_any(int8);
+
+drop type vint2 cascade;
+drop type vint4 cascade;
+drop type vint8 cascade;
+drop type vfloat8 cascade;
+drop type vfloat4 cascade;
+drop type vbool cascade;
+drop type vdateadt cascade;