Changeset: 5a782c9d6e0b for MonetDB
URL: http://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=5a782c9d6e0b
Added Files:
        clients/Tests/MAL-signatures.sql
Removed Files:
        clients/Tests/MAL-signatures.malC
Modified Files:
        clients/Tests/MAL-signatures.stable.out
        clients/Tests/MAL-signatures.stable.out.int128
Branch: default
Log Message:

Change MAL-signatures test now that ?* doesn't work anymore in MAL.


diffs (truncated from 95681 to 300 lines):

diff --git a/clients/Tests/MAL-signatures.malC 
b/clients/Tests/MAL-signatures.malC
deleted file mode 100644
--- a/clients/Tests/MAL-signatures.malC
+++ /dev/null
@@ -1,1 +0,0 @@
-?*)
diff --git a/clients/Tests/MAL-signatures.sql b/clients/Tests/MAL-signatures.sql
new file mode 100644
--- /dev/null
+++ b/clients/Tests/MAL-signatures.sql
@@ -0,0 +1,1 @@
+select * from sys.malfunctions() order by module, "function", address, 
signature, comment;
diff --git a/clients/Tests/MAL-signatures.stable.out 
b/clients/Tests/MAL-signatures.stable.out
--- a/clients/Tests/MAL-signatures.stable.out
+++ b/clients/Tests/MAL-signatures.stable.out
@@ -15,33240 +15,8696 @@ stdout of test 'MAL-signatures` in direc
 # Visit http://www.monetdb.org/ for further information
 
 Ready.
+# SQL catalog created, loading sql scripts once
+# loading sql script: 09_like.sql
+# loading sql script: 10_math.sql
+# loading sql script: 11_times.sql
+# loading sql script: 12_url.sql
+# loading sql script: 13_date.sql
+# loading sql script: 14_inet.sql
+# loading sql script: 15_querylog.sql
+# loading sql script: 16_tracelog.sql
+# loading sql script: 17_temporal.sql
+# loading sql script: 18_index.sql
+# loading sql script: 20_vacuum.sql
+# loading sql script: 21_dependency_functions.sql
+# loading sql script: 22_clients.sql
+# loading sql script: 23_skyserver.sql
+# loading sql script: 24_zorder.sql
+# loading sql script: 25_debug.sql
+# loading sql script: 26_sysmon.sql
+# loading sql script: 27_rejects.sql
+# loading sql script: 39_analytics.sql
+# loading sql script: 40_geom.sql
+# loading sql script: 40_json.sql
+# loading sql script: 41_md5sum.sql
+# loading sql script: 45_uuid.sql
+# loading sql script: 46_gsl.sql
+# loading sql script: 46_profiler.sql
+# loading sql script: 51_sys_schema_extension.sql
+# loading sql script: 72_fits.sql
+# loading sql script: 74_netcdf.sql
+# loading sql script: 75_shp.sql
+# loading sql script: 75_storagemodel.sql
+# loading sql script: 80_statistics.sql
+# loading sql script: 80_udf.sql
+# loading sql script: 85_bam.sql
+# loading sql script: 90_generator.sql
+# loading sql script: 99_system.sql
 
-# 17:25:33 >  
-# 17:25:33 >  "mclient" "-lmal" "-ftest" "-Eutf-8" 
"--host=/var/tmp/mtest-25210" "--port=34276"
-# 17:25:33 >  
+# 14:39:22 >  
+# 14:39:22 >  "mclient" "-lsql" "-ftest" "-Eutf-8" "-i" "-e" 
"--host=/var/tmp/mtest-23085" "--port=30158"
+# 14:39:22 >  
 
-command aggr.avg(b:bat[:dbl],g:bat[:oid],e:bat[:any_1]) 
(X_0:bat[:dbl],X_1:bat[:lng]) 
-address AGGRavg23_dbl;
-comment Grouped tail average on dbl, also returns count
+#select * from sys.malfunctions() order by module, "function", address, 
signature, comment;
+% .,   .,      .,      .,      . # table_name
+% module,      function,       signature,      address,        comment # name
+% clob,        clob,   clob,   clob,   clob # type
+% 11,  28,     312,    44,     874 # length
+[ "aggr",      "avg",  "command 
aggr.avg(b:bat[:bte],g:bat[:oid],e:bat[:any_1]):bat[:dbl] ",   
"AGGRavg13_dbl;",       "Grouped tail average on bte"   ]
+[ "aggr",      "avg",  "command 
aggr.avg(b:bat[:dbl],g:bat[:oid],e:bat[:any_1]):bat[:dbl] ",   
"AGGRavg13_dbl;",       "Grouped tail average on dbl"   ]
+[ "aggr",      "avg",  "command 
aggr.avg(b:bat[:flt],g:bat[:oid],e:bat[:any_1]):bat[:dbl] ",   
"AGGRavg13_dbl;",       "Grouped tail average on flt"   ]
+[ "aggr",      "avg",  "command 
aggr.avg(b:bat[:int],g:bat[:oid],e:bat[:any_1]):bat[:dbl] ",   
"AGGRavg13_dbl;",       "Grouped tail average on int"   ]
+[ "aggr",      "avg",  "command 
aggr.avg(b:bat[:lng],g:bat[:oid],e:bat[:any_1]):bat[:dbl] ",   
"AGGRavg13_dbl;",       "Grouped tail average on lng"   ]
+[ "aggr",      "avg",  "command 
aggr.avg(b:bat[:sht],g:bat[:oid],e:bat[:any_1]):bat[:dbl] ",   
"AGGRavg13_dbl;",       "Grouped tail average on sht"   ]
+[ "aggr",      "avg",  "command 
aggr.avg(b:bat[:bte],g:bat[:oid],e:bat[:any_1]) (X_0:bat[:dbl],X_1:bat[:lng]) 
",       "AGGRavg23_dbl;",       "Grouped tail average on bte, also returns 
count"       ]
+[ "aggr",      "avg",  "command 
aggr.avg(b:bat[:dbl],g:bat[:oid],e:bat[:any_1]) (X_0:bat[:dbl],X_1:bat[:lng]) 
",       "AGGRavg23_dbl;",       "Grouped tail average on dbl, also returns 
count"       ]
+[ "aggr",      "avg",  "command 
aggr.avg(b:bat[:flt],g:bat[:oid],e:bat[:any_1]) (X_0:bat[:dbl],X_1:bat[:lng]) 
",       "AGGRavg23_dbl;",       "Grouped tail average on flt, also returns 
count"       ]
+[ "aggr",      "avg",  "command 
aggr.avg(b:bat[:int],g:bat[:oid],e:bat[:any_1]) (X_0:bat[:dbl],X_1:bat[:lng]) 
",       "AGGRavg23_dbl;",       "Grouped tail average on int, also returns 
count"       ]
+[ "aggr",      "avg",  "command 
aggr.avg(b:bat[:lng],g:bat[:oid],e:bat[:any_1]) (X_0:bat[:dbl],X_1:bat[:lng]) 
",       "AGGRavg23_dbl;",       "Grouped tail average on lng, also returns 
count"       ]
+[ "aggr",      "avg",  "command 
aggr.avg(b:bat[:sht],g:bat[:oid],e:bat[:any_1]) (X_0:bat[:dbl],X_1:bat[:lng]) 
",       "AGGRavg23_dbl;",       "Grouped tail average on sht, also returns 
count"       ]
+[ "aggr",      "avg",  "pattern aggr.avg(b:bat[:any_2]):dbl ", "CMDcalcavg;",  
"Gives the avg of all tail values"      ]
+[ "aggr",      "cardinality",  "command aggr.cardinality(b:bat[:any_2]):lng ", 
"ALGcard;",     "Return the cardinality of the BAT tail values."        ]
+[ "aggr",      "corr", "function aggr.corr(e1:bat[:bte],e2:bat[:bte]):bte;",   
"",     ""      ]
+[ "aggr",      "corr", "function aggr.corr(e1:bat[:dbl],e2:bat[:dbl]):dbl;",   
"",     ""      ]
+[ "aggr",      "corr", "function aggr.corr(e1:bat[:flt],e2:bat[:flt]):flt;",   
"",     ""      ]
+[ "aggr",      "corr", "function aggr.corr(e1:bat[:int],e2:bat[:int]):int;",   
"",     ""      ]
+[ "aggr",      "corr", "function aggr.corr(e1:bat[:lng],e2:bat[:lng]):lng;",   
"",     ""      ]
+[ "aggr",      "corr", "function aggr.corr(e1:bat[:sht],e2:bat[:sht]):sht;",   
"",     ""      ]
+[ "aggr",      "count",        "command 
aggr.count(b:bat[:any_1],g:bat[:oid],e:bat[:any_2],ignorenils:bit):bat[:lng] ", 
       "AGGRcount3;",  ""      ]
+[ "aggr",      "count",        "command 
aggr.count(b:bat[:any_1],g:bat[:oid],e:bat[:any_2]):bat[:lng] ",       
"AGGRcount3nils;",      "Grouped count" ]
+[ "aggr",      "count",        "command aggr.count(b:bat[:any]):lng ", 
"ALGcount_bat;",        "Return the current size (in number of elements) in a 
BAT."     ]
+[ "aggr",      "count",        "command 
aggr.count(b:bat[:any],ignore_nils:bit):lng ", "ALGcount_nil;",        "Return 
the number of elements currently in a BAT ignores\n\t\tBUNs with nil-tail iff 
ignore_nils==TRUE."       ]
+[ "aggr",      "count_no_nil", "command 
aggr.count_no_nil(b:bat[:any_1],g:bat[:oid],e:bat[:any_2]):bat[:lng] ",        
"AGGRcount3nonils;",    ""      ]
+[ "aggr",      "count_no_nil", "command aggr.count_no_nil(b:bat[:any_2]):lng 
",        "ALGcount_no_nil;",     "Return the number of elements 
currently\n\tin a BAT ignoring BUNs with nil-tail"       ]
+[ "aggr",      "covar",        "function 
aggr.covar(e1:bat[:bte],e2:bat[:bte]):bte;",  "",     ""      ]
+[ "aggr",      "covar",        "function 
aggr.covar(e1:bat[:dbl],e2:bat[:dbl]):dbl;",  "",     ""      ]
+[ "aggr",      "covar",        "function 
aggr.covar(e1:bat[:flt],e2:bat[:flt]):flt;",  "",     ""      ]
+[ "aggr",      "covar",        "function 
aggr.covar(e1:bat[:int],e2:bat[:int]):int;",  "",     ""      ]
+[ "aggr",      "covar",        "function 
aggr.covar(e1:bat[:lng],e2:bat[:lng]):lng;",  "",     ""      ]
+[ "aggr",      "covar",        "function 
aggr.covar(e1:bat[:sht],e2:bat[:sht]):sht;",  "",     ""      ]
+[ "aggr",      "exist",        "command aggr.exist(b:bat[:any_2],h:any_1):bit 
",       "ALGexist;",    ""      ]
+[ "aggr",      "jsonaggr",     "command aggr.jsonaggr(val:bat[:dbl]):str ",    
"JSONgroupStr;",        "Aggregate the double values to array." ]
+[ "aggr",      "jsonaggr",     "command aggr.jsonaggr(val:bat[:str]):str ",    
"JSONgroupStr;",        "Aggregate the string values to array." ]
+[ "aggr",      "max",  "command 
aggr.max(b:bat[:any_1],g:bat[:oid],e:bat[:any_2]):bat[:any_1] ",       
"AGGRmax3;",    ""      ]
+[ "aggr",      "max",  "command aggr.max(b:bat[:any_2]):any_2 ",       
"ALGmaxany;",   "Return the highest tail value or nil." ]
+[ "aggr",      "median",       "function aggr.median(b:bat[:any_1]):any_1;",   
"",     ""      ]
+[ "aggr",      "median",       "command 
aggr.median(b:bat[:any_1],g:bat[:oid],e:bat[:any_2]):bat[:any_1] ",    
"AGGRmedian3;", "Grouped median aggregate"      ]
+[ "aggr",      "min",  "command 
aggr.min(b:bat[:any_1],g:bat[:oid],e:bat[:any_2]):bat[:any_1] ",       
"AGGRmin3;",    ""      ]
+[ "aggr",      "min",  "command aggr.min(b:bat[:any_2]):any_2 ",       
"ALGminany;",   "Return the lowest tail value or nil."  ]
+[ "aggr",      "prod", "command 
aggr.prod(b:bat[:bte],g:bat[:oid],e:bat[:any_1]):bat[:bte] ",  
"AGGRprod3_bte;",       "Grouped tail product on bte"   ]
+[ "aggr",      "prod", "command 
aggr.prod(b:bat[:dbl],g:bat[:oid],e:bat[:any_1]):bat[:dbl] ",  
"AGGRprod3_dbl;",       "Grouped tail product on dbl"   ]
+[ "aggr",      "prod", "command 
aggr.prod(b:bat[:flt],g:bat[:oid],e:bat[:any_1]):bat[:dbl] ",  
"AGGRprod3_dbl;",       "Grouped tail product on flt"   ]
+[ "aggr",      "prod", "command 
aggr.prod(b:bat[:flt],g:bat[:oid],e:bat[:any_1]):bat[:flt] ",  
"AGGRprod3_flt;",       "Grouped tail product on flt"   ]
+[ "aggr",      "prod", "command 
aggr.prod(b:bat[:bte],g:bat[:oid],e:bat[:any_1]):bat[:int] ",  
"AGGRprod3_int;",       "Grouped tail product on bte"   ]
+[ "aggr",      "prod", "command 
aggr.prod(b:bat[:int],g:bat[:oid],e:bat[:any_1]):bat[:int] ",  
"AGGRprod3_int;",       "Grouped tail product on int"   ]
+[ "aggr",      "prod", "command 
aggr.prod(b:bat[:sht],g:bat[:oid],e:bat[:any_1]):bat[:int] ",  
"AGGRprod3_int;",       "Grouped tail product on sht"   ]
+[ "aggr",      "prod", "command 
aggr.prod(b:bat[:bte],g:bat[:oid],e:bat[:any_1]):bat[:lng] ",  
"AGGRprod3_lng;",       "Grouped tail product on bte"   ]
+[ "aggr",      "prod", "command 
aggr.prod(b:bat[:int],g:bat[:oid],e:bat[:any_1]):bat[:lng] ",  
"AGGRprod3_lng;",       "Grouped tail product on int"   ]
+[ "aggr",      "prod", "command 
aggr.prod(b:bat[:lng],g:bat[:oid],e:bat[:any_1]):bat[:lng] ",  
"AGGRprod3_lng;",       "Grouped tail product on lng"   ]
+[ "aggr",      "prod", "command 
aggr.prod(b:bat[:sht],g:bat[:oid],e:bat[:any_1]):bat[:lng] ",  
"AGGRprod3_lng;",       "Grouped tail product on sht"   ]
+[ "aggr",      "prod", "command 
aggr.prod(b:bat[:bte],g:bat[:oid],e:bat[:any_1]):bat[:sht] ",  
"AGGRprod3_sht;",       "Grouped tail product on bte"   ]
+[ "aggr",      "prod", "command 
aggr.prod(b:bat[:sht],g:bat[:oid],e:bat[:any_1]):bat[:sht] ",  
"AGGRprod3_sht;",       "Grouped tail product on sht"   ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:bte]):bte ",  "CMDBATprod;",  
"Calculate aggregate product of B."     ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:bte]):dbl ",  "CMDBATprod;",  
"Calculate aggregate product of B."     ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:bte]):int ",  "CMDBATprod;",  
"Calculate aggregate product of B."     ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:bte]):lng ",  "CMDBATprod;",  
"Calculate aggregate product of B."     ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:bte]):sht ",  "CMDBATprod;",  
"Calculate aggregate product of B."     ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:bte],nil_if_empty:bit):bte ", 
"CMDBATprod;",  "Calculate aggregate product of B."     ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:bte],nil_if_empty:bit):dbl ", 
"CMDBATprod;",  "Calculate aggregate product of B."     ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:bte],nil_if_empty:bit):int ", 
"CMDBATprod;",  "Calculate aggregate product of B."     ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:bte],nil_if_empty:bit):lng ", 
"CMDBATprod;",  "Calculate aggregate product of B."     ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:bte],nil_if_empty:bit):sht ", 
"CMDBATprod;",  "Calculate aggregate product of B."     ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:bte],s:bat[:oid]):bte ",      
"CMDBATprod;",  "Calculate aggregate product of B with candidate list." ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:bte],s:bat[:oid]):dbl ",      
"CMDBATprod;",  "Calculate aggregate product of B with candidate list." ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:bte],s:bat[:oid]):int ",      
"CMDBATprod;",  "Calculate aggregate product of B with candidate list." ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:bte],s:bat[:oid]):lng ",      
"CMDBATprod;",  "Calculate aggregate product of B with candidate list." ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:bte],s:bat[:oid]):sht ",      
"CMDBATprod;",  "Calculate aggregate product of B with candidate list." ]
+[ "aggr",      "prod", "pattern 
aggr.prod(b:bat[:bte],s:bat[:oid],nil_if_empty:bit):bte ",     "CMDBATprod;",  
"Calculate aggregate product of B with candidate list." ]
+[ "aggr",      "prod", "pattern 
aggr.prod(b:bat[:bte],s:bat[:oid],nil_if_empty:bit):dbl ",     "CMDBATprod;",  
"Calculate aggregate product of B with candidate list." ]
+[ "aggr",      "prod", "pattern 
aggr.prod(b:bat[:bte],s:bat[:oid],nil_if_empty:bit):int ",     "CMDBATprod;",  
"Calculate aggregate product of B with candidate list." ]
+[ "aggr",      "prod", "pattern 
aggr.prod(b:bat[:bte],s:bat[:oid],nil_if_empty:bit):lng ",     "CMDBATprod;",  
"Calculate aggregate product of B with candidate list." ]
+[ "aggr",      "prod", "pattern 
aggr.prod(b:bat[:bte],s:bat[:oid],nil_if_empty:bit):sht ",     "CMDBATprod;",  
"Calculate aggregate product of B with candidate list." ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:dbl]):dbl ",  "CMDBATprod;",  
"Calculate aggregate product of B."     ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:dbl],nil_if_empty:bit):dbl ", 
"CMDBATprod;",  "Calculate aggregate product of B."     ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:dbl],s:bat[:oid]):dbl ",      
"CMDBATprod;",  "Calculate aggregate product of B with candidate list." ]
+[ "aggr",      "prod", "pattern 
aggr.prod(b:bat[:dbl],s:bat[:oid],nil_if_empty:bit):dbl ",     "CMDBATprod;",  
"Calculate aggregate product of B with candidate list." ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:flt]):dbl ",  "CMDBATprod;",  
"Calculate aggregate product of B."     ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:flt]):flt ",  "CMDBATprod;",  
"Calculate aggregate product of B."     ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:flt],nil_if_empty:bit):dbl ", 
"CMDBATprod;",  "Calculate aggregate product of B."     ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:flt],nil_if_empty:bit):flt ", 
"CMDBATprod;",  "Calculate aggregate product of B."     ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:flt],s:bat[:oid]):dbl ",      
"CMDBATprod;",  "Calculate aggregate product of B with candidate list." ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:flt],s:bat[:oid]):flt ",      
"CMDBATprod;",  "Calculate aggregate product of B with candidate list." ]
+[ "aggr",      "prod", "pattern 
aggr.prod(b:bat[:flt],s:bat[:oid],nil_if_empty:bit):dbl ",     "CMDBATprod;",  
"Calculate aggregate product of B with candidate list." ]
+[ "aggr",      "prod", "pattern 
aggr.prod(b:bat[:flt],s:bat[:oid],nil_if_empty:bit):flt ",     "CMDBATprod;",  
"Calculate aggregate product of B with candidate list." ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:int]):dbl ",  "CMDBATprod;",  
"Calculate aggregate product of B."     ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:int]):int ",  "CMDBATprod;",  
"Calculate aggregate product of B."     ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:int]):lng ",  "CMDBATprod;",  
"Calculate aggregate product of B."     ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:int],nil_if_empty:bit):dbl ", 
"CMDBATprod;",  "Calculate aggregate product of B."     ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:int],nil_if_empty:bit):int ", 
"CMDBATprod;",  "Calculate aggregate product of B."     ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:int],nil_if_empty:bit):lng ", 
"CMDBATprod;",  "Calculate aggregate product of B."     ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:int],s:bat[:oid]):dbl ",      
"CMDBATprod;",  "Calculate aggregate product of B with candidate list." ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:int],s:bat[:oid]):int ",      
"CMDBATprod;",  "Calculate aggregate product of B with candidate list." ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:int],s:bat[:oid]):lng ",      
"CMDBATprod;",  "Calculate aggregate product of B with candidate list." ]
+[ "aggr",      "prod", "pattern 
aggr.prod(b:bat[:int],s:bat[:oid],nil_if_empty:bit):dbl ",     "CMDBATprod;",  
"Calculate aggregate product of B with candidate list." ]
+[ "aggr",      "prod", "pattern 
aggr.prod(b:bat[:int],s:bat[:oid],nil_if_empty:bit):int ",     "CMDBATprod;",  
"Calculate aggregate product of B with candidate list." ]
+[ "aggr",      "prod", "pattern 
aggr.prod(b:bat[:int],s:bat[:oid],nil_if_empty:bit):lng ",     "CMDBATprod;",  
"Calculate aggregate product of B with candidate list." ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:lng]):dbl ",  "CMDBATprod;",  
"Calculate aggregate product of B."     ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:lng]):lng ",  "CMDBATprod;",  
"Calculate aggregate product of B."     ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:lng],nil_if_empty:bit):dbl ", 
"CMDBATprod;",  "Calculate aggregate product of B."     ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:lng],nil_if_empty:bit):lng ", 
"CMDBATprod;",  "Calculate aggregate product of B."     ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:lng],s:bat[:oid]):dbl ",      
"CMDBATprod;",  "Calculate aggregate product of B with candidate list." ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:lng],s:bat[:oid]):lng ",      
"CMDBATprod;",  "Calculate aggregate product of B with candidate list." ]
+[ "aggr",      "prod", "pattern 
aggr.prod(b:bat[:lng],s:bat[:oid],nil_if_empty:bit):dbl ",     "CMDBATprod;",  
"Calculate aggregate product of B with candidate list." ]
+[ "aggr",      "prod", "pattern 
aggr.prod(b:bat[:lng],s:bat[:oid],nil_if_empty:bit):lng ",     "CMDBATprod;",  
"Calculate aggregate product of B with candidate list." ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:sht]):dbl ",  "CMDBATprod;",  
"Calculate aggregate product of B."     ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:sht]):int ",  "CMDBATprod;",  
"Calculate aggregate product of B."     ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:sht]):lng ",  "CMDBATprod;",  
"Calculate aggregate product of B."     ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:sht]):sht ",  "CMDBATprod;",  
"Calculate aggregate product of B."     ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:sht],nil_if_empty:bit):dbl ", 
"CMDBATprod;",  "Calculate aggregate product of B."     ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:sht],nil_if_empty:bit):int ", 
"CMDBATprod;",  "Calculate aggregate product of B."     ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:sht],nil_if_empty:bit):lng ", 
"CMDBATprod;",  "Calculate aggregate product of B."     ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:sht],nil_if_empty:bit):sht ", 
"CMDBATprod;",  "Calculate aggregate product of B."     ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:sht],s:bat[:oid]):dbl ",      
"CMDBATprod;",  "Calculate aggregate product of B with candidate list." ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:sht],s:bat[:oid]):int ",      
"CMDBATprod;",  "Calculate aggregate product of B with candidate list." ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:sht],s:bat[:oid]):lng ",      
"CMDBATprod;",  "Calculate aggregate product of B with candidate list." ]
+[ "aggr",      "prod", "pattern aggr.prod(b:bat[:sht],s:bat[:oid]):sht ",      
"CMDBATprod;",  "Calculate aggregate product of B with candidate list." ]
+[ "aggr",      "prod", "pattern 
aggr.prod(b:bat[:sht],s:bat[:oid],nil_if_empty:bit):dbl ",     "CMDBATprod;",  
"Calculate aggregate product of B with candidate list." ]
+[ "aggr",      "prod", "pattern 
aggr.prod(b:bat[:sht],s:bat[:oid],nil_if_empty:bit):int ",     "CMDBATprod;",  
"Calculate aggregate product of B with candidate list." ]
+[ "aggr",      "prod", "pattern 
aggr.prod(b:bat[:sht],s:bat[:oid],nil_if_empty:bit):lng ",     "CMDBATprod;",  
"Calculate aggregate product of B with candidate list." ]
+[ "aggr",      "prod", "pattern 
aggr.prod(b:bat[:sht],s:bat[:oid],nil_if_empty:bit):sht ",     "CMDBATprod;",  
"Calculate aggregate product of B with candidate list." ]
+[ "aggr",      "quantile",     "function 
aggr.quantile(b:bat[:any_1],q:bat[:dbl]):any_1;",     "",     ""      ]
+[ "aggr",      "quantile",     "command 
aggr.quantile(b:bat[:any_1],g:bat[:oid],e:bat[:any_2],q:bat[:dbl]):bat[:any_1] 
",      "AGGRquantile3;",       "Grouped quantile aggregate"    ]
+[ "aggr",      "stdev",        "command 
aggr.stdev(b:bat[:bte],g:bat[:oid],e:bat[:any_1]):bat[:dbl] ", 
"AGGRstdev3_dbl;",      "Grouped tail standard deviation (sample/non-biased) on 
bte"    ]
+[ "aggr",      "stdev",        "command 
aggr.stdev(b:bat[:dbl],g:bat[:oid],e:bat[:any_1]):bat[:dbl] ", 
"AGGRstdev3_dbl;",      "Grouped tail standard deviation (sample/non-biased) on 
dbl"    ]
+[ "aggr",      "stdev",        "command 
aggr.stdev(b:bat[:flt],g:bat[:oid],e:bat[:any_1]):bat[:dbl] ", 
"AGGRstdev3_dbl;",      "Grouped tail standard deviation (sample/non-biased) on 
flt"    ]
+[ "aggr",      "stdev",        "command 
aggr.stdev(b:bat[:int],g:bat[:oid],e:bat[:any_1]):bat[:dbl] ", 
"AGGRstdev3_dbl;",      "Grouped tail standard deviation (sample/non-biased) on 
int"    ]
+[ "aggr",      "stdev",        "command 
aggr.stdev(b:bat[:lng],g:bat[:oid],e:bat[:any_1]):bat[:dbl] ", 
"AGGRstdev3_dbl;",      "Grouped tail standard deviation (sample/non-biased) on 
lng"    ]
+[ "aggr",      "stdev",        "command 
aggr.stdev(b:bat[:sht],g:bat[:oid],e:bat[:any_1]):bat[:dbl] ", 
"AGGRstdev3_dbl;",      "Grouped tail standard deviation (sample/non-biased) on 
sht"    ]
+[ "aggr",      "stdev",        "command aggr.stdev(b:bat[:any_2]):dbl ",       
"ALGstdev;",    "Gives the standard deviation of all tail values"       ]
+[ "aggr",      "stdevp",       "command 
aggr.stdevp(b:bat[:bte],g:bat[:oid],e:bat[:any_1]):bat[:dbl] ",        
"AGGRstdevp3_dbl;",     "Grouped tail standard deviation (population/biased) on 
bte"    ]
+[ "aggr",      "stdevp",       "command 
aggr.stdevp(b:bat[:dbl],g:bat[:oid],e:bat[:any_1]):bat[:dbl] ",        
"AGGRstdevp3_dbl;",     "Grouped tail standard deviation (population/biased) on 
dbl"    ]
+[ "aggr",      "stdevp",       "command 
aggr.stdevp(b:bat[:flt],g:bat[:oid],e:bat[:any_1]):bat[:dbl] ",        
"AGGRstdevp3_dbl;",     "Grouped tail standard deviation (population/biased) on 
flt"    ]
+[ "aggr",      "stdevp",       "command 
aggr.stdevp(b:bat[:int],g:bat[:oid],e:bat[:any_1]):bat[:dbl] ",        
"AGGRstdevp3_dbl;",     "Grouped tail standard deviation (population/biased) on 
int"    ]
+[ "aggr",      "stdevp",       "command 
aggr.stdevp(b:bat[:lng],g:bat[:oid],e:bat[:any_1]):bat[:dbl] ",        
"AGGRstdevp3_dbl;",     "Grouped tail standard deviation (population/biased) on 
lng"    ]
+[ "aggr",      "stdevp",       "command 
aggr.stdevp(b:bat[:sht],g:bat[:oid],e:bat[:any_1]):bat[:dbl] ",        
"AGGRstdevp3_dbl;",     "Grouped tail standard deviation (population/biased) on 
sht"    ]
+[ "aggr",      "stdevp",       "command aggr.stdevp(b:bat[:any_2]):dbl ",      
"ALGstdevp;",   "Gives the standard deviation of all tail values"       ]
+[ "aggr",      "subavg",       "command 
aggr.subavg(b:bat[:bte],g:bat[:oid],e:bat[:any_1],skip_nils:bit,abort_on_error:bit):bat[:dbl]
 ",       "AGGRsubavg1_dbl;",     "Grouped average aggregate"     ]
+[ "aggr",      "subavg",       "command 
aggr.subavg(b:bat[:dbl],g:bat[:oid],e:bat[:any_1],skip_nils:bit,abort_on_error:bit):bat[:dbl]
 ",       "AGGRsubavg1_dbl;",     "Grouped average aggregate"     ]
+[ "aggr",      "subavg",       "command 
aggr.subavg(b:bat[:flt],g:bat[:oid],e:bat[:any_1],skip_nils:bit,abort_on_error:bit):bat[:dbl]
 ",       "AGGRsubavg1_dbl;",     "Grouped average aggregate"     ]
+[ "aggr",      "subavg",       "command 
aggr.subavg(b:bat[:int],g:bat[:oid],e:bat[:any_1],skip_nils:bit,abort_on_error:bit):bat[:dbl]
 ",       "AGGRsubavg1_dbl;",     "Grouped average aggregate"     ]
+[ "aggr",      "subavg",       "command 
aggr.subavg(b:bat[:lng],g:bat[:oid],e:bat[:any_1],skip_nils:bit,abort_on_error:bit):bat[:dbl]
 ",       "AGGRsubavg1_dbl;",     "Grouped average aggregate"     ]
+[ "aggr",      "subavg",       "command 
aggr.subavg(b:bat[:sht],g:bat[:oid],e:bat[:any_1],skip_nils:bit,abort_on_error:bit):bat[:dbl]
 ",       "AGGRsubavg1_dbl;",     "Grouped average aggregate"     ]
+[ "aggr",      "subavg",       "command 
aggr.subavg(b:bat[:bte],g:bat[:oid],e:bat[:any_1],s:bat[:oid],skip_nils:bit,abort_on_error:bit):bat[:dbl]
 ",   "AGGRsubavg1cand_dbl;", "Grouped average aggregate with candidates list"  
      ]
+[ "aggr",      "subavg",       "command 
aggr.subavg(b:bat[:dbl],g:bat[:oid],e:bat[:any_1],s:bat[:oid],skip_nils:bit,abort_on_error:bit):bat[:dbl]
 ",   "AGGRsubavg1cand_dbl;", "Grouped average aggregate with candidates list"  
      ]
+[ "aggr",      "subavg",       "command 
aggr.subavg(b:bat[:flt],g:bat[:oid],e:bat[:any_1],s:bat[:oid],skip_nils:bit,abort_on_error:bit):bat[:dbl]
 ",   "AGGRsubavg1cand_dbl;", "Grouped average aggregate with candidates list"  
      ]
+[ "aggr",      "subavg",       "command 
aggr.subavg(b:bat[:int],g:bat[:oid],e:bat[:any_1],s:bat[:oid],skip_nils:bit,abort_on_error:bit):bat[:dbl]
 ",   "AGGRsubavg1cand_dbl;", "Grouped average aggregate with candidates list"  
      ]
+[ "aggr",      "subavg",       "command 
aggr.subavg(b:bat[:lng],g:bat[:oid],e:bat[:any_1],s:bat[:oid],skip_nils:bit,abort_on_error:bit):bat[:dbl]
 ",   "AGGRsubavg1cand_dbl;", "Grouped average aggregate with candidates list"  
      ]
+[ "aggr",      "subavg",       "command 
aggr.subavg(b:bat[:sht],g:bat[:oid],e:bat[:any_1],s:bat[:oid],skip_nils:bit,abort_on_error:bit):bat[:dbl]
 ",   "AGGRsubavg1cand_dbl;", "Grouped average aggregate with candidates list"  
      ]
+[ "aggr",      "subavg",       "command 
aggr.subavg(b:bat[:bte],g:bat[:oid],e:bat[:any_1],skip_nils:bit,abort_on_error:bit)
 (X_0:bat[:dbl],X_1:bat[:lng]) ",   "AGGRsubavg2_dbl;",     "Grouped average 
aggregate, also returns count" ]
+[ "aggr",      "subavg",       "command 
aggr.subavg(b:bat[:dbl],g:bat[:oid],e:bat[:any_1],skip_nils:bit,abort_on_error:bit)
 (X_0:bat[:dbl],X_1:bat[:lng]) ",   "AGGRsubavg2_dbl;",     "Grouped average 
aggregate, also returns count" ]
+[ "aggr",      "subavg",       "command 
aggr.subavg(b:bat[:flt],g:bat[:oid],e:bat[:any_1],skip_nils:bit,abort_on_error:bit)
 (X_0:bat[:dbl],X_1:bat[:lng]) ",   "AGGRsubavg2_dbl;",     "Grouped average 
aggregate, also returns count" ]
+[ "aggr",      "subavg",       "command 
aggr.subavg(b:bat[:int],g:bat[:oid],e:bat[:any_1],skip_nils:bit,abort_on_error:bit)
 (X_0:bat[:dbl],X_1:bat[:lng]) ",   "AGGRsubavg2_dbl;",     "Grouped average 
aggregate, also returns count" ]
+[ "aggr",      "subavg",       "command 
aggr.subavg(b:bat[:lng],g:bat[:oid],e:bat[:any_1],skip_nils:bit,abort_on_error:bit)
 (X_0:bat[:dbl],X_1:bat[:lng]) ",   "AGGRsubavg2_dbl;",     "Grouped average 
aggregate, also returns count" ]
+[ "aggr",      "subavg",       "command 
aggr.subavg(b:bat[:sht],g:bat[:oid],e:bat[:any_1],skip_nils:bit,abort_on_error:bit)
 (X_0:bat[:dbl],X_1:bat[:lng]) ",   "AGGRsubavg2_dbl;",     "Grouped average 
aggregate, also returns count" ]
+[ "aggr",      "subavg",       "command 
aggr.subavg(b:bat[:bte],g:bat[:oid],e:bat[:any_1],s:bat[:oid],skip_nils:bit,abort_on_error:bit)
 (X_0:bat[:dbl],X_1:bat[:lng]) ",       "AGGRsubavg2cand_dbl;", "Grouped 
average aggregate with candidates list, also returns count"    ]
+[ "aggr",      "subavg",       "command 
aggr.subavg(b:bat[:dbl],g:bat[:oid],e:bat[:any_1],s:bat[:oid],skip_nils:bit,abort_on_error:bit)
 (X_0:bat[:dbl],X_1:bat[:lng]) ",       "AGGRsubavg2cand_dbl;", "Grouped 
average aggregate with candidates list, also returns count"    ]
+[ "aggr",      "subavg",       "command 
aggr.subavg(b:bat[:flt],g:bat[:oid],e:bat[:any_1],s:bat[:oid],skip_nils:bit,abort_on_error:bit)
 (X_0:bat[:dbl],X_1:bat[:lng]) ",       "AGGRsubavg2cand_dbl;", "Grouped 
average aggregate with candidates list, also returns count"    ]
+[ "aggr",      "subavg",       "command 
aggr.subavg(b:bat[:int],g:bat[:oid],e:bat[:any_1],s:bat[:oid],skip_nils:bit,abort_on_error:bit)
 (X_0:bat[:dbl],X_1:bat[:lng]) ",       "AGGRsubavg2cand_dbl;", "Grouped 
average aggregate with candidates list, also returns count"    ]
+[ "aggr",      "subavg",       "command 
aggr.subavg(b:bat[:lng],g:bat[:oid],e:bat[:any_1],s:bat[:oid],skip_nils:bit,abort_on_error:bit)
 (X_0:bat[:dbl],X_1:bat[:lng]) ",       "AGGRsubavg2cand_dbl;", "Grouped 
average aggregate with candidates list, also returns count"    ]
+[ "aggr",      "subavg",       "command 
aggr.subavg(b:bat[:sht],g:bat[:oid],e:bat[:any_1],s:bat[:oid],skip_nils:bit,abort_on_error:bit)
 (X_0:bat[:dbl],X_1:bat[:lng]) ",       "AGGRsubavg2cand_dbl;", "Grouped 
average aggregate with candidates list, also returns count"    ]
+[ "aggr",      "subcorr",      "function 
aggr.subcorr(e1:bat[:bte],e2:bat[:bte],g:bat[:oid],e:bat[:any_2],f:bit):bat[:bte];",
  "",     ""      ]
+[ "aggr",      "subcorr",      "function 
aggr.subcorr(e1:bat[:dbl],e2:bat[:dbl],g:bat[:oid],e:bat[:any_2],f:bit):bat[:dbl];",
  "",     ""      ]
+[ "aggr",      "subcorr",      "function 
aggr.subcorr(e1:bat[:flt],e2:bat[:flt],g:bat[:oid],e:bat[:any_2],f:bit):bat[:flt];",
  "",     ""      ]
+[ "aggr",      "subcorr",      "function 
aggr.subcorr(e1:bat[:int],e2:bat[:int],g:bat[:oid],e:bat[:any_2],f:bit):bat[:int];",
  "",     ""      ]
+[ "aggr",      "subcorr",      "function 
aggr.subcorr(e1:bat[:lng],e2:bat[:lng],g:bat[:oid],e:bat[:any_2],f:bit):bat[:lng];",
  "",     ""      ]
+[ "aggr",      "subcorr",      "function 
aggr.subcorr(e1:bat[:sht],e2:bat[:sht],g:bat[:oid],e:bat[:any_2],f:bit):bat[:sht];",
  "",     ""      ]
+[ "aggr",      "subcount",     "command 
aggr.subcount(b:bat[:any_1],g:bat[:oid],e:bat[:any_2],skip_nils:bit):bat[:lng] 
",      "AGGRsubcount;",        "Grouped count aggregate"       ]
+[ "aggr",      "subcount",     "command 
aggr.subcount(b:bat[:any_1],g:bat[:oid],e:bat[:any_2],s:bat[:oid],skip_nils:bit):bat[:lng]
 ",  "AGGRsubcountcand;",    "Grouped count aggregate with candidates list"  ]
+[ "aggr",      "subcovar",     "function 
aggr.subcovar(e1:bat[:bte],e2:bat[:bte],g:bat[:oid],e:bat[:any_2],f:bit):bat[:bte];",
 "",     ""      ]
+[ "aggr",      "subcovar",     "function 
aggr.subcovar(e1:bat[:dbl],e2:bat[:dbl],g:bat[:oid],e:bat[:any_2],f:bit):bat[:dbl];",
 "",     ""      ]
+[ "aggr",      "subcovar",     "function 
aggr.subcovar(e1:bat[:flt],e2:bat[:flt],g:bat[:oid],e:bat[:any_2],f:bit):bat[:flt];",
 "",     ""      ]
+[ "aggr",      "subcovar",     "function 
aggr.subcovar(e1:bat[:int],e2:bat[:int],g:bat[:oid],e:bat[:any_2],f:bit):bat[:int];",
 "",     ""      ]
+[ "aggr",      "subcovar",     "function 
aggr.subcovar(e1:bat[:lng],e2:bat[:lng],g:bat[:oid],e:bat[:any_2],f:bit):bat[:lng];",
 "",     ""      ]
+[ "aggr",      "subcovar",     "function 
aggr.subcovar(e1:bat[:sht],e2:bat[:sht],g:bat[:oid],e:bat[:any_2],f:bit):bat[:sht];",
 "",     ""      ]
+[ "aggr",      "subjsonaggr",  "command 
aggr.subjsonaggr(val:bat[:dbl],g:bat[:oid],e:bat[:any_1],skip_nils:bit):bat[:str]
 ",   "JSONsubjson;", "Grouped aggregation of values."        ]
+[ "aggr",      "subjsonaggr",  "command 
aggr.subjsonaggr(val:bat[:str],g:bat[:oid],e:bat[:any_1],skip_nils:bit):bat[:str]
 ",   "JSONsubjson;", "Grouped aggregation of values."        ]
+[ "aggr",      "subjsonaggr",  "command 
aggr.subjsonaggr(val:bat[:dbl],g:bat[:oid],e:bat[:any_1],s:bat[:oid],skip_nils:bit):bat[:str]
 ",       "JSONsubjsoncand;",     "Grouped aggregation of values with 
candidates list."   ]
+[ "aggr",      "subjsonaggr",  "command 
aggr.subjsonaggr(val:bat[:str],g:bat[:oid],e:bat[:any_1],s:bat[:oid],skip_nils:bit):bat[:str]
 ",       "JSONsubjsoncand;",     "Grouped aggregation of values with 
candidates list."   ]
+[ "aggr",      "submax",       "command 
aggr.submax(b:bat[:any_1],g:bat[:oid],e:bat[:any_2],skip_nils:bit):bat[:oid] ", 
       "AGGRsubmax;",  "Grouped maximum aggregate"     ]
+[ "aggr",      "submax",       "command 
aggr.submax(b:bat[:any_1],g:bat[:oid],e:bat[:any_2],skip_nils:bit):bat[:any_1] 
",      "AGGRsubmax_val;",      "Grouped maximum aggregate"     ]
+[ "aggr",      "submax",       "command 
aggr.submax(b:bat[:any_1],g:bat[:oid],e:bat[:any_2],s:bat[:oid],skip_nils:bit):bat[:oid]
 ",    "AGGRsubmaxcand;",      "Grouped maximum aggregate with candidates list" 
       ]
+[ "aggr",      "submax",       "command 
aggr.submax(b:bat[:any_1],g:bat[:oid],e:bat[:any_2],s:bat[:oid],skip_nils:bit):bat[:any_1]
 ",  "AGGRsubmaxcand_val;",  "Grouped maximum aggregate with candidates list"   
     ]
+[ "aggr",      "submedian",    "command 
aggr.submedian(b:bat[:any_1],skip_nils:bit):bat[:any_1] ",     "AGGRmedian;",  
"Median aggregate"      ]
+[ "aggr",      "submedian",    "command 
aggr.submedian(b:bat[:any_1],g:bat[:oid],e:bat[:any_2],skip_nils:bit):bat[:any_1]
 ",   "AGGRsubmedian;",       "Grouped median aggregate"      ]
+[ "aggr",      "submedian",    "command 
aggr.submedian(b:bat[:any_1],g:bat[:oid],e:bat[:any_2],s:bat[:oid],skip_nils:bit):bat[:any_1]
 ",       "AGGRsubmediancand;",   "Grouped median aggregate with candidate 
list"  ]
+[ "aggr",      "submin",       "command 
aggr.submin(b:bat[:any_1],g:bat[:oid],e:bat[:any_2],skip_nils:bit):bat[:oid] ", 
       "AGGRsubmin;",  "Grouped minimum aggregate"     ]
+[ "aggr",      "submin",       "command 
aggr.submin(b:bat[:any_1],g:bat[:oid],e:bat[:any_2],skip_nils:bit):bat[:any_1] 
",      "AGGRsubmin_val;",      "Grouped minimum aggregate"     ]
+[ "aggr",      "submin",       "command 
aggr.submin(b:bat[:any_1],g:bat[:oid],e:bat[:any_2],s:bat[:oid],skip_nils:bit):bat[:oid]
 ",    "AGGRsubmincand;",      "Grouped minimum aggregate with candidates list" 
       ]
+[ "aggr",      "submin",       "command 
aggr.submin(b:bat[:any_1],g:bat[:oid],e:bat[:any_2],s:bat[:oid],skip_nils:bit):bat[:any_1]
 ",  "AGGRsubmincand_val;",  "Grouped minimum aggregate with candidates list"   
     ]
+[ "aggr",      "subprod",      "command 
aggr.subprod(b:bat[:bte],g:bat[:oid],e:bat[:any_1],skip_nils:bit,abort_on_error:bit):bat[:bte]
 ",      "AGGRsubprod_bte;",     "Grouped product aggregate"     ]
+[ "aggr",      "subprod",      "command 
aggr.subprod(b:bat[:dbl],g:bat[:oid],e:bat[:any_1],skip_nils:bit,abort_on_error:bit):bat[:dbl]
 ",      "AGGRsubprod_dbl;",     "Grouped product aggregate"     ]
+[ "aggr",      "subprod",      "command 
aggr.subprod(b:bat[:flt],g:bat[:oid],e:bat[:any_1],skip_nils:bit,abort_on_error:bit):bat[:dbl]
 ",      "AGGRsubprod_dbl;",     "Grouped product aggregate"     ]
+[ "aggr",      "subprod",      "command 
aggr.subprod(b:bat[:flt],g:bat[:oid],e:bat[:any_1],skip_nils:bit,abort_on_error:bit):bat[:flt]
 ",      "AGGRsubprod_flt;",     "Grouped product aggregate"     ]
+[ "aggr",      "subprod",      "command 
aggr.subprod(b:bat[:bte],g:bat[:oid],e:bat[:any_1],skip_nils:bit,abort_on_error:bit):bat[:int]
 ",      "AGGRsubprod_int;",     "Grouped product aggregate"     ]
+[ "aggr",      "subprod",      "command 
aggr.subprod(b:bat[:int],g:bat[:oid],e:bat[:any_1],skip_nils:bit,abort_on_error:bit):bat[:int]
 ",      "AGGRsubprod_int;",     "Grouped product aggregate"     ]
+[ "aggr",      "subprod",      "command 
aggr.subprod(b:bat[:sht],g:bat[:oid],e:bat[:any_1],skip_nils:bit,abort_on_error:bit):bat[:int]
 ",      "AGGRsubprod_int;",     "Grouped product aggregate"     ]
+[ "aggr",      "subprod",      "command 
aggr.subprod(b:bat[:bte],g:bat[:oid],e:bat[:any_1],skip_nils:bit,abort_on_error:bit):bat[:lng]
 ",      "AGGRsubprod_lng;",     "Grouped product aggregate"     ]
+[ "aggr",      "subprod",      "command 
aggr.subprod(b:bat[:int],g:bat[:oid],e:bat[:any_1],skip_nils:bit,abort_on_error:bit):bat[:lng]
 ",      "AGGRsubprod_lng;",     "Grouped product aggregate"     ]
+[ "aggr",      "subprod",      "command 
aggr.subprod(b:bat[:lng],g:bat[:oid],e:bat[:any_1],skip_nils:bit,abort_on_error:bit):bat[:lng]
 ",      "AGGRsubprod_lng;",     "Grouped product aggregate"     ]
+[ "aggr",      "subprod",      "command 
aggr.subprod(b:bat[:sht],g:bat[:oid],e:bat[:any_1],skip_nils:bit,abort_on_error:bit):bat[:lng]
 ",      "AGGRsubprod_lng;",     "Grouped product aggregate"     ]
+[ "aggr",      "subprod",      "command 
aggr.subprod(b:bat[:bte],g:bat[:oid],e:bat[:any_1],skip_nils:bit,abort_on_error:bit):bat[:sht]
 ",      "AGGRsubprod_sht;",     "Grouped product aggregate"     ]
+[ "aggr",      "subprod",      "command 
aggr.subprod(b:bat[:sht],g:bat[:oid],e:bat[:any_1],skip_nils:bit,abort_on_error:bit):bat[:sht]
 ",      "AGGRsubprod_sht;",     "Grouped product aggregate"     ]
+[ "aggr",      "subprod",      "command 
aggr.subprod(b:bat[:bte],g:bat[:oid],e:bat[:any_1],s:bat[:oid],skip_nils:bit,abort_on_error:bit):bat[:bte]
 ",  "AGGRsubprodcand_bte;", "Grouped product aggregate with candidates list"   
     ]
+[ "aggr",      "subprod",      "command 
aggr.subprod(b:bat[:dbl],g:bat[:oid],e:bat[:any_1],s:bat[:oid],skip_nils:bit,abort_on_error:bit):bat[:dbl]
 ",  "AGGRsubprodcand_dbl;", "Grouped product aggregate with candidates list"   
     ]
+[ "aggr",      "subprod",      "command 
aggr.subprod(b:bat[:flt],g:bat[:oid],e:bat[:any_1],s:bat[:oid],skip_nils:bit,abort_on_error:bit):bat[:dbl]
 ",  "AGGRsubprodcand_dbl;", "Grouped product aggregate with candidates list"   
     ]
+[ "aggr",      "subprod",      "command 
aggr.subprod(b:bat[:flt],g:bat[:oid],e:bat[:any_1],s:bat[:oid],skip_nils:bit,abort_on_error:bit):bat[:flt]
 ",  "AGGRsubprodcand_flt;", "Grouped product aggregate with candidates list"   
     ]
+[ "aggr",      "subprod",      "command 
aggr.subprod(b:bat[:bte],g:bat[:oid],e:bat[:any_1],s:bat[:oid],skip_nils:bit,abort_on_error:bit):bat[:int]
 ",  "AGGRsubprodcand_int;", "Grouped product aggregate with candidates list"   
     ]
+[ "aggr",      "subprod",      "command 
aggr.subprod(b:bat[:int],g:bat[:oid],e:bat[:any_1],s:bat[:oid],skip_nils:bit,abort_on_error:bit):bat[:int]
 ",  "AGGRsubprodcand_int;", "Grouped product aggregate with candidates list"   
     ]
+[ "aggr",      "subprod",      "command 
aggr.subprod(b:bat[:sht],g:bat[:oid],e:bat[:any_1],s:bat[:oid],skip_nils:bit,abort_on_error:bit):bat[:int]
 ",  "AGGRsubprodcand_int;", "Grouped product aggregate with candidates list"   
     ]
+[ "aggr",      "subprod",      "command 
aggr.subprod(b:bat[:bte],g:bat[:oid],e:bat[:any_1],s:bat[:oid],skip_nils:bit,abort_on_error:bit):bat[:lng]
 ",  "AGGRsubprodcand_lng;", "Grouped product aggregate with candidates list"   
     ]
+[ "aggr",      "subprod",      "command 
aggr.subprod(b:bat[:int],g:bat[:oid],e:bat[:any_1],s:bat[:oid],skip_nils:bit,abort_on_error:bit):bat[:lng]
 ",  "AGGRsubprodcand_lng;", "Grouped product aggregate with candidates list"   
     ]
+[ "aggr",      "subprod",      "command 
aggr.subprod(b:bat[:lng],g:bat[:oid],e:bat[:any_1],s:bat[:oid],skip_nils:bit,abort_on_error:bit):bat[:lng]
 ",  "AGGRsubprodcand_lng;", "Grouped product aggregate with candidates list"   
     ]
+[ "aggr",      "subprod",      "command 
aggr.subprod(b:bat[:sht],g:bat[:oid],e:bat[:any_1],s:bat[:oid],skip_nils:bit,abort_on_error:bit):bat[:lng]
 ",  "AGGRsubprodcand_lng;", "Grouped product aggregate with candidates list"   
     ]
+[ "aggr",      "subprod",      "command 
aggr.subprod(b:bat[:bte],g:bat[:oid],e:bat[:any_1],s:bat[:oid],skip_nils:bit,abort_on_error:bit):bat[:sht]
 ",  "AGGRsubprodcand_sht;", "Grouped product aggregate with candidates list"   
     ]
+[ "aggr",      "subprod",      "command 
aggr.subprod(b:bat[:sht],g:bat[:oid],e:bat[:any_1],s:bat[:oid],skip_nils:bit,abort_on_error:bit):bat[:sht]
 ",  "AGGRsubprodcand_sht;", "Grouped product aggregate with candidates list"   
     ]
+[ "aggr",      "subquantile",  "command 
aggr.subquantile(b:bat[:any_1],q:bat[:dbl],skip_nils:bit):bat[:any_1] ",       
"AGGRquantile;",        "Quantile aggregate"    ]
+[ "aggr",      "subquantile",  "command 
aggr.subquantile(b:bat[:any_1],q:bat[:dbl],g:bat[:oid],e:bat[:any_2],skip_nils:bit):bat[:any_1]
 ",     "AGGRsubquantile;",     "Grouped quantile aggregate"    ]
+[ "aggr",      "subquantile",  "command 
aggr.subquantile(b:bat[:any_1],q:bat[:dbl],g:bat[:oid],e:bat[:any_2],s:bat[:oid],skip_nils:bit):bat[:any_1]
 ", "AGGRsubquantilecand;", "Grouped median quantile with candidate list"   ]
+[ "aggr",      "substdev",     "command 
aggr.substdev(b:bat[:bte],g:bat[:oid],e:bat[:any_1],skip_nils:bit,abort_on_error:bit):bat[:dbl]
 ",     "AGGRsubstdev_dbl;",    "Grouped standard deviation (sample/non-biased) 
aggregate"      ]
+[ "aggr",      "substdev",     "command 
aggr.substdev(b:bat[:dbl],g:bat[:oid],e:bat[:any_1],skip_nils:bit,abort_on_error:bit):bat[:dbl]
 ",     "AGGRsubstdev_dbl;",    "Grouped standard deviation (sample/non-biased) 
aggregate"      ]
+[ "aggr",      "substdev",     "command 
aggr.substdev(b:bat[:flt],g:bat[:oid],e:bat[:any_1],skip_nils:bit,abort_on_error:bit):bat[:dbl]
 ",     "AGGRsubstdev_dbl;",    "Grouped standard deviation (sample/non-biased) 
aggregate"      ]
+[ "aggr",      "substdev",     "command 
aggr.substdev(b:bat[:int],g:bat[:oid],e:bat[:any_1],skip_nils:bit,abort_on_error:bit):bat[:dbl]
 ",     "AGGRsubstdev_dbl;",    "Grouped standard deviation (sample/non-biased) 
aggregate"      ]
+[ "aggr",      "substdev",     "command 
aggr.substdev(b:bat[:lng],g:bat[:oid],e:bat[:any_1],skip_nils:bit,abort_on_error:bit):bat[:dbl]
 ",     "AGGRsubstdev_dbl;",    "Grouped standard deviation (sample/non-biased) 
aggregate"      ]
+[ "aggr",      "substdev",     "command 
aggr.substdev(b:bat[:sht],g:bat[:oid],e:bat[:any_1],skip_nils:bit,abort_on_error:bit):bat[:dbl]
 ",     "AGGRsubstdev_dbl;",    "Grouped standard deviation (sample/non-biased) 
aggregate"      ]
+[ "aggr",      "substdev",     "command 
aggr.substdev(b:bat[:bte],g:bat[:oid],e:bat[:any_1],s:bat[:oid],skip_nils:bit,abort_on_error:bit):bat[:dbl]
 ", "AGGRsubstdevcand_dbl;",        "Grouped standard deviation 
(sample/non-biased) aggregate with candidates list" ]
+[ "aggr",      "substdev",     "command 
aggr.substdev(b:bat[:dbl],g:bat[:oid],e:bat[:any_1],s:bat[:oid],skip_nils:bit,abort_on_error:bit):bat[:dbl]
 ", "AGGRsubstdevcand_dbl;",        "Grouped standard deviation 
(sample/non-biased) aggregate with candidates list" ]
+[ "aggr",      "substdev",     "command 
aggr.substdev(b:bat[:flt],g:bat[:oid],e:bat[:any_1],s:bat[:oid],skip_nils:bit,abort_on_error:bit):bat[:dbl]
 ", "AGGRsubstdevcand_dbl;",        "Grouped standard deviation 
(sample/non-biased) aggregate with candidates list" ]
_______________________________________________
checkin-list mailing list
checkin-list@monetdb.org
https://www.monetdb.org/mailman/listinfo/checkin-list

Reply via email to