-/* ------------------------------------------------
-Copyright 2014 AT&T Intellectual Property
- Licensed 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 "rts_udaf.h"
-#include "gsconfig.h"
-#include "gstypes.h"
-#include <stdio.h>
-#include <limits.h>
-#include <math.h>
-
-
-#define max(a,b) ((a) > (b) ? (a) : (b))
-#define MAX_BUFSIZE 128
-
-
-/****************************************************************/
-/* LFTA functions */
-/****************************************************************/
-
-
-////////////////////////////////////////////////////////////////////////
-//// avg_udaf
-
-typedef struct avg_udaf_lfta_struct_t{
- gs_int64_t sum;
- gs_uint32_t cnt;
-} avg_udaf_lfta_struct_t;
-
-void avg_udaf_lfta_LFTA_AGGR_INIT_(gs_sp_t b){
- avg_udaf_lfta_struct_t *s = (avg_udaf_lfta_struct_t *)b;
- s->sum = 0;
- s->cnt = 0;
-}
-
-void avg_udaf_lfta_LFTA_AGGR_UPDATE_(gs_sp_t b,gs_uint32_t v){
- avg_udaf_lfta_struct_t *s = (avg_udaf_lfta_struct_t *)b;
- s->sum += v;
- s->cnt++;
-}
-
-gs_retval_t avg_udaf_lfta_LFTA_AGGR_FLUSHME_(gs_sp_t b){
- return 0;
-}
-
-void avg_udaf_lfta_LFTA_AGGR_OUTPUT_(struct gs_string *r,gs_sp_t b){
- r->length = 12;
- r->data = b;
-}
-
-void avg_udaf_lfta_LFTA_AGGR_DESTROY_(gs_sp_t b){
- return;
-}
-
-/////////////////////////////////////////////////////////
-// Moving sum
-
-typedef struct moving_sum_lfta_struct{
- gs_uint32_t sum;
- gs_uint32_t N;
-} moving_sum_lfta_struct;
-
-void moving_sum_lfta_LFTA_AGGR_INIT_(gs_sp_t b){
- moving_sum_lfta_struct *s = (moving_sum_lfta_struct *)b;
- s->sum = 0;
- s->N = 0;
-}
-
-void moving_sum_lfta_LFTA_AGGR_UPDATE_(gs_sp_t b, gs_uint32_t v, gs_uint32_t N){
- moving_sum_lfta_struct *s = (moving_sum_lfta_struct *)b;
- s->sum += v;
- s->N = N;
-}
-
-gs_retval_t moving_sum_lfta_LFTA_AGGR_FLUSHME_(gs_sp_t b){
- return 0;
-}
-
-void moving_sum_lfta_LFTA_AGGR_OUTPUT_(gs_uint64_t *r, gs_sp_t b){
- moving_sum_lfta_struct *s = (moving_sum_lfta_struct *)b;
- *r = ((gs_uint64_t)(s->N) << 32) | (gs_uint64_t)(s->sum);
-}
-
-gs_retval_t moving_sum_lfta_LFTA_AGGR_DESTROY_(gs_sp_t b){
- return 0;
-}
-
-/////////////////////////////////////////////////////////
-// FIRST and LAST aggregates
-
-void FIRST_lfta_LFTA_AGGR_INIT_(gs_uint32_t* scratch) {
- *scratch = UINT_MAX; // we will encode uninitialized value of UINT_MAX
- return;
-}
-
-void FIRST_lfta_LFTA_AGGR_UPDATE_(gs_uint32_t* scratch, gs_uint32_t val) {
- if (*scratch == UINT_MAX)
- *scratch = val;
- return;
-}
-
-gs_retval_t FIRST_lfta_LFTA_AGGR_FLUSHME_( gs_uint32_t* scratch) { return 0; }
-
-void FIRST_lfta_LFTA_AGGR_OUTPUT_(gs_uint32_t* res, gs_uint32_t* scratch) {
- *res = *scratch;
-}
-
-void FIRST_lfta_LFTA_AGGR_DESTROY_(gs_uint32_t* scratch) { return; }
-
-void FIRST_ULL_lfta_LFTA_AGGR_INIT_(gs_uint64_t* scratch) {
- *scratch = ULLONG_MAX; // we will encode uninitialized value of ULLONG_MAX
- return;
-}
-
-void FIRST_ULL_lfta_LFTA_AGGR_UPDATE_(gs_uint64_t* scratch, gs_uint64_t val) {
- if (*scratch == ULLONG_MAX)
- *scratch = val;
- return;
-}
-
-gs_retval_t FIRST_ULL_lfta_LFTA_AGGR_FLUSHME_( gs_uint64_t* scratch) { return 0; }
-
-void FIRST_ULL_lfta_LFTA_AGGR_OUTPUT_(gs_uint64_t* res, gs_uint64_t* scratch) {
- *res = *scratch;
-}
-
-void FIRST_ULL_lfta_LFTA_AGGR_DESTROY_(gs_uint64_t* scratch) { return; }
-
-
-
-void FIRST_STR_lfta_LFTA_AGGR_INIT_(struct gs_string* scratch) {
- scratch->data = NULL;
- return;
-}
-
-void FIRST_STR_lfta_LFTA_AGGR_UPDATE_(struct gs_string* scratch, struct gs_string* val) {
- if (!scratch->data) {
- str_assign_with_copy(NULL, scratch, val);
- }
- return;
-}
-
-gs_retval_t FIRST_STR_lfta_LFTA_AGGR_FLUSHME_(struct gs_string* scratch) { return 0; }
-
-void FIRST_STR_lfta_LFTA_AGGR_OUTPUT_(struct gs_string* res, struct gs_string* scratch) {
- *res = *scratch;
-}
-
-void FIRST_STR_lfta_LFTA_AGGR_DESTROY_(struct gs_string* scratch) {
- if (scratch->data)
- fta_free(NULL, scratch->data);
-}
-
-void LAST_lfta_LFTA_AGGR_INIT_(gs_uint32_t* scratch) { }
-
-void LAST_lfta_LFTA_AGGR_UPDATE_(gs_uint32_t* scratch, gs_uint32_t val) {
- *scratch = val;
- return;
-}
-
-gs_retval_t LAST_lfta_LFTA_AGGR_FLUSHME_( gs_uint32_t* scratch) { return 0; }
-
-void LAST_lfta_LFTA_AGGR_OUTPUT_(gs_uint32_t* res, gs_uint32_t* scratch) {
- *res = *scratch;
-}
-
-void LAST_lfta_LFTA_AGGR_DESTROY_(gs_uint32_t* scratch) { return; }
-
-void LAST_ULL_lfta_LFTA_AGGR_INIT_(gs_uint64_t* scratch) { }
-
-void LAST_ULL_lfta_LFTA_AGGR_UPDATE_(gs_uint64_t* scratch, gs_uint64_t val) {
- *scratch = val;
- return;
-}
-
-gs_retval_t LAST_ULL_lfta_LFTA_AGGR_FLUSHME_( gs_uint64_t* scratch) { return 0; }
-
-void LAST_ULL_lfta_LFTA_AGGR_OUTPUT_(gs_uint64_t* res, gs_uint64_t* scratch) {
- *res = *scratch;
-}
-
-void LAST_ULL_lfta_LFTA_AGGR_DESTROY_(gs_uint64_t* scratch) { return; }
-
-
-
-void LAST_STR_lfta_LFTA_AGGR_INIT_(struct gs_string* scratch) {
- scratch->data = NULL;
- return;
-}
-
-void LAST_STR_lfta_LFTA_AGGR_UPDATE_(struct gs_string* scratch, struct gs_string* val) {
- if (!scratch->data) {
- str_assign_with_copy(NULL, scratch, val);
- } else {
- if (!str_compare(scratch, val)) {
- fta_free(NULL, scratch->data);
- str_assign_with_copy(NULL, scratch, val);
- }
- }
- return;
-}
-
-gs_retval_t LAST_STR_lfta_LFTA_AGGR_FLUSHME_(struct gs_string* scratch) { return 0; }
-
-void LAST_STR_lfta_LFTA_AGGR_OUTPUT_(struct gs_string* res, struct gs_string* scratch) {
- *res = *scratch;
-}
-
-void LAST_STR_lfta_LFTA_AGGR_DESTROY_(struct gs_string* scratch) {
- if (scratch->data)
- fta_free(NULL, scratch->data);
-}
-
-
-/////////////////////////////////////////////////////////
-// running_array_aggr aggregate
-
-struct running_array_aggr_str{
- gs_uint32_t num_list[4];
- gs_uint8_t n_num;
-};
-
-void running_array_aggr_lfta_LFTA_AGGR_INIT_(char* scratch) {
- struct running_array_aggr_str* aggr = (struct running_array_aggr_str*)scratch;
- aggr->n_num = 0;
-}
-
-void running_array_aggr_lfta_LFTA_AGGR_UPDATE_(char* scratch, gs_uint32_t val) {
- struct running_array_aggr_str* aggr = (struct running_array_aggr_str*)scratch;
- aggr->num_list[aggr->n_num++] = val;
-}
-
-gs_retval_t running_array_aggr_lfta_LFTA_AGGR_FLUSHME_(char* scratch) {
- struct running_array_aggr_str* aggr = (struct running_array_aggr_str*)scratch;
- return (aggr->n_num == 4);
-}
-void running_array_aggr_lfta_LFTA_AGGR_OUTPUT_(struct gs_string* res, char* scratch) {
- struct running_array_aggr_str* aggr = (struct running_array_aggr_str*)scratch;
- res->data = scratch;
- res->length = aggr->n_num * sizeof(gs_uint32_t);
- res->owner = NULL;
-}
-
-void running_array_aggr_lfta_LFTA_AGGR_DESTROY_(char* scratch) { }
-
+/* ------------------------------------------------\r
+Copyright 2014 AT&T Intellectual Property\r
+ Licensed under the Apache License, Version 2.0 (the "License");\r
+ you may not use this file except in compliance with the License.\r
+ You may obtain a copy of the License at\r
+\r
+ http://www.apache.org/licenses/LICENSE-2.0\r
+\r
+ Unless required by applicable law or agreed to in writing, software\r
+ distributed under the License is distributed on an "AS IS" BASIS,\r
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ See the License for the specific language governing permissions and\r
+ limitations under the License.\r
+ ------------------------------------------- */\r
+\r
+#include "rts_udaf.h"\r
+#include "gsconfig.h"\r
+#include "gstypes.h"\r
+#include <stdio.h>\r
+#include <limits.h>\r
+#include <math.h>\r
+\r
+\r
+#define max(a,b) ((a) > (b) ? (a) : (b))\r
+#define MAX_BUFSIZE 128\r
+\r
+\r
+/****************************************************************/\r
+/* LFTA functions */\r
+/****************************************************************/\r
+\r
+\r
+////////////////////////////////////////////////////////////////////////\r
+//// avg_udaf\r
+\r
+typedef struct avg_udaf_lfta_struct_t{\r
+ gs_int64_t sum;\r
+ gs_uint32_t cnt;\r
+} avg_udaf_lfta_struct_t;\r
+\r
+void avg_udaf_lfta_LFTA_AGGR_INIT_(gs_sp_t b){\r
+ avg_udaf_lfta_struct_t *s = (avg_udaf_lfta_struct_t *)b;\r
+ s->sum = 0;\r
+ s->cnt = 0;\r
+}\r
+\r
+void avg_udaf_lfta_LFTA_AGGR_UPDATE_(gs_sp_t b,gs_uint32_t v){\r
+ avg_udaf_lfta_struct_t *s = (avg_udaf_lfta_struct_t *)b;\r
+ s->sum += v;\r
+ s->cnt++;\r
+}\r
+\r
+gs_retval_t avg_udaf_lfta_LFTA_AGGR_FLUSHME_(gs_sp_t b){\r
+ return 0;\r
+}\r
+\r
+void avg_udaf_lfta_LFTA_AGGR_OUTPUT_(struct gs_string *r,gs_sp_t b){\r
+ r->length = 12;\r
+ r->data = b;\r
+}\r
+\r
+void avg_udaf_lfta_LFTA_AGGR_DESTROY_(gs_sp_t b){\r
+ return;\r
+}\r
+\r
+/////////////////////////////////////////////////////////\r
+// Moving sum\r
+\r
+typedef struct moving_sum_lfta_struct{\r
+ gs_uint32_t sum;\r
+ gs_uint32_t N;\r
+} moving_sum_lfta_struct;\r
+\r
+void moving_sum_lfta_LFTA_AGGR_INIT_(gs_sp_t b){\r
+ moving_sum_lfta_struct *s = (moving_sum_lfta_struct *)b;\r
+ s->sum = 0;\r
+ s->N = 0;\r
+}\r
+\r
+void moving_sum_lfta_LFTA_AGGR_UPDATE_(gs_sp_t b, gs_uint32_t v, gs_uint32_t N){\r
+ moving_sum_lfta_struct *s = (moving_sum_lfta_struct *)b;\r
+ s->sum += v;\r
+ s->N = N;\r
+}\r
+ \r
+gs_retval_t moving_sum_lfta_LFTA_AGGR_FLUSHME_(gs_sp_t b){\r
+ return 0;\r
+}\r
+\r
+void moving_sum_lfta_LFTA_AGGR_OUTPUT_(gs_uint64_t *r, gs_sp_t b){\r
+ moving_sum_lfta_struct *s = (moving_sum_lfta_struct *)b;\r
+ *r = ((gs_uint64_t)(s->N) << 32) | (gs_uint64_t)(s->sum);\r
+}\r
+\r
+gs_retval_t moving_sum_lfta_LFTA_AGGR_DESTROY_(gs_sp_t b){\r
+ return 0;\r
+}\r
+\r
+/////////////////////////////////////////////////////////\r
+// FIRST and LAST aggregates\r
+\r
+void FIRST_lfta_LFTA_AGGR_INIT_(gs_uint32_t* scratch) {\r
+ *scratch = UINT_MAX; // we will encode uninitialized value of UINT_MAX\r
+ return;\r
+}\r
+\r
+void FIRST_lfta_LFTA_AGGR_UPDATE_(gs_uint32_t* scratch, gs_uint32_t val) {\r
+ if (*scratch == UINT_MAX)\r
+ *scratch = val;\r
+ return;\r
+}\r
+\r
+gs_retval_t FIRST_lfta_LFTA_AGGR_FLUSHME_( gs_uint32_t* scratch) { return 0; }\r
+\r
+void FIRST_lfta_LFTA_AGGR_OUTPUT_(gs_uint32_t* res, gs_uint32_t* scratch) {\r
+ *res = *scratch;\r
+}\r
+\r
+void FIRST_lfta_LFTA_AGGR_DESTROY_(gs_uint32_t* scratch) { return; }\r
+\r
+void FIRST_ULL_lfta_LFTA_AGGR_INIT_(gs_uint64_t* scratch) {\r
+ *scratch = ULLONG_MAX; // we will encode uninitialized value of ULLONG_MAX\r
+ return;\r
+}\r
+\r
+void FIRST_ULL_lfta_LFTA_AGGR_UPDATE_(gs_uint64_t* scratch, gs_uint64_t val) {\r
+ if (*scratch == ULLONG_MAX)\r
+ *scratch = val;\r
+ return;\r
+}\r
+\r
+gs_retval_t FIRST_ULL_lfta_LFTA_AGGR_FLUSHME_( gs_uint64_t* scratch) { return 0; }\r
+\r
+void FIRST_ULL_lfta_LFTA_AGGR_OUTPUT_(gs_uint64_t* res, gs_uint64_t* scratch) {\r
+ *res = *scratch;\r
+}\r
+\r
+void FIRST_ULL_lfta_LFTA_AGGR_DESTROY_(gs_uint64_t* scratch) { return; }\r
+\r
+\r
+\r
+void FIRST_STR_lfta_LFTA_AGGR_INIT_(struct gs_string* scratch) {\r
+ scratch->data = NULL;\r
+ return;\r
+}\r
+\r
+void FIRST_STR_lfta_LFTA_AGGR_UPDATE_(struct gs_string* scratch, struct gs_string* val) {\r
+ if (!scratch->data) {\r
+ str_assign_with_copy(NULL, scratch, val);\r
+ }\r
+ return;\r
+}\r
+\r
+gs_retval_t FIRST_STR_lfta_LFTA_AGGR_FLUSHME_(struct gs_string* scratch) { return 0; }\r
+\r
+void FIRST_STR_lfta_LFTA_AGGR_OUTPUT_(struct gs_string* res, struct gs_string* scratch) {\r
+ *res = *scratch;\r
+}\r
+\r
+void FIRST_STR_lfta_LFTA_AGGR_DESTROY_(struct gs_string* scratch) { \r
+ if (scratch->data) \r
+ fta_free(NULL, scratch->data);\r
+}\r
+\r
+void LAST_lfta_LFTA_AGGR_INIT_(gs_uint32_t* scratch) { }\r
+\r
+void LAST_lfta_LFTA_AGGR_UPDATE_(gs_uint32_t* scratch, gs_uint32_t val) {\r
+ *scratch = val;\r
+ return;\r
+}\r
+\r
+gs_retval_t LAST_lfta_LFTA_AGGR_FLUSHME_( gs_uint32_t* scratch) { return 0; }\r
+\r
+void LAST_lfta_LFTA_AGGR_OUTPUT_(gs_uint32_t* res, gs_uint32_t* scratch) {\r
+ *res = *scratch;\r
+}\r
+\r
+void LAST_lfta_LFTA_AGGR_DESTROY_(gs_uint32_t* scratch) { return; }\r
+\r
+void LAST_ULL_lfta_LFTA_AGGR_INIT_(gs_uint64_t* scratch) { }\r
+\r
+void LAST_ULL_lfta_LFTA_AGGR_UPDATE_(gs_uint64_t* scratch, gs_uint64_t val) {\r
+ *scratch = val;\r
+ return;\r
+}\r
+\r
+gs_retval_t LAST_ULL_lfta_LFTA_AGGR_FLUSHME_( gs_uint64_t* scratch) { return 0; }\r
+\r
+void LAST_ULL_lfta_LFTA_AGGR_OUTPUT_(gs_uint64_t* res, gs_uint64_t* scratch) {\r
+ *res = *scratch;\r
+}\r
+\r
+void LAST_ULL_lfta_LFTA_AGGR_DESTROY_(gs_uint64_t* scratch) { return; }\r
+\r
+\r
+\r
+void LAST_STR_lfta_LFTA_AGGR_INIT_(struct gs_string* scratch) {\r
+ scratch->data = NULL;\r
+ return;\r
+}\r
+\r
+void LAST_STR_lfta_LFTA_AGGR_UPDATE_(struct gs_string* scratch, struct gs_string* val) {\r
+ if (!scratch->data) {\r
+ str_assign_with_copy(NULL, scratch, val);\r
+ } else {\r
+ if (!str_compare(scratch, val)) {\r
+ fta_free(NULL, scratch->data);\r
+ str_assign_with_copy(NULL, scratch, val);\r
+ }\r
+ }\r
+ return;\r
+}\r
+\r
+gs_retval_t LAST_STR_lfta_LFTA_AGGR_FLUSHME_(struct gs_string* scratch) { return 0; }\r
+\r
+void LAST_STR_lfta_LFTA_AGGR_OUTPUT_(struct gs_string* res, struct gs_string* scratch) {\r
+ *res = *scratch;\r
+}\r
+\r
+void LAST_STR_lfta_LFTA_AGGR_DESTROY_(struct gs_string* scratch) { \r
+ if (scratch->data) \r
+ fta_free(NULL, scratch->data);\r
+}\r
+\r
+\r
+/////////////////////////////////////////////////////////\r
+// running_array_aggr aggregate\r
+\r
+struct running_array_aggr_str{\r
+ gs_uint32_t num_list[4];\r
+ gs_uint8_t n_num;\r
+};\r
+\r
+void running_array_aggr_lfta_LFTA_AGGR_INIT_(char* scratch) {\r
+ struct running_array_aggr_str* aggr = (struct running_array_aggr_str*)scratch;\r
+ aggr->n_num = 0;\r
+}\r
+\r
+void running_array_aggr_lfta_LFTA_AGGR_UPDATE_(char* scratch, gs_uint32_t val) {\r
+ struct running_array_aggr_str* aggr = (struct running_array_aggr_str*)scratch;\r
+ aggr->num_list[aggr->n_num++] = val;\r
+}\r
+\r
+gs_retval_t running_array_aggr_lfta_LFTA_AGGR_FLUSHME_(char* scratch) {\r
+ struct running_array_aggr_str* aggr = (struct running_array_aggr_str*)scratch;\r
+ return (aggr->n_num == 4);\r
+}\r
+void running_array_aggr_lfta_LFTA_AGGR_OUTPUT_(struct gs_string* res, char* scratch) {\r
+ struct running_array_aggr_str* aggr = (struct running_array_aggr_str*)scratch; \r
+ res->data = scratch;\r
+ res->length = aggr->n_num * sizeof(gs_uint32_t);\r
+ res->owner = NULL;\r
+}\r
+\r
+void running_array_aggr_lfta_LFTA_AGGR_DESTROY_(char* scratch) { }\r
+\r
Code Review / com / gs-lite.git / blobdiff