counter_get change

13 files changed, 56 insertions, 41 deletions

diff --git a/include/fieldstat/fieldstat.h b/include/fieldstat/fieldstat.h
index 2f6c7e2..9b3b3bb 100644
--- a/include/fieldstat/fieldstat.h
+++ b/include/fieldstat/fieldstat.h
@@ -242,9 +242,10 @@ int fieldstat_get_max_cell_id(const struct fieldstat *instance, int cube_id);
     * @param cube_id: cube id, previously returned by fieldstat_get_cubes.
     * @param metric_id: metric id, previously returned by fieldstat_get_max_metric_id.
     * @param cell_id: cell id, previously returned by fieldstat_get_cells.
-    * @return -1 if cube_id or metric_id or cell_id is invalid.
+    * @param value_out: the value of the metric. If the cell is not found, *value_out is set to 0.
+    * @return -1 if cube_id or metric_id or cell_id is invalid. 
 */
-long long fieldstat_counter_get(const struct fieldstat *instance, int cube_id, int metric_id, int cell_id);
+int fieldstat_counter_get(const struct fieldstat *instance, int cube_id, int metric_id, int cell_id, long long *value_out);
 double fieldstat_hll_get(const struct fieldstat *instance, int cube_id, int metric_id, int cell_id);
 long long fieldstat_hist_value_at_percentile(const struct fieldstat *instance, int cube_id, int metric_id, int cell_id, double percentile);
 long long fieldstat_hist_count_le_value(const struct fieldstat *instance, int cube_id, int metric_id, int cell_id, long long value);
diff --git a/src/exporter/cjson_exporter.c b/src/exporter/cjson_exporter.c
index 5c1baa9..94c0cf3 100644
--- a/src/exporter/cjson_exporter.c
+++ b/src/exporter/cjson_exporter.c
@@ -486,8 +486,9 @@ struct export_kv_pair *cell_query_with_iter(const struct cell_iter *iter, int me
     enum metric_type type = fieldstat_get_metric_type(iter->instance, iter->cube_ids[iter->curr_cube_idx], metric_id);
     struct export_kv_pair *ret = NULL;
     if (type == METRIC_TYPE_COUNTER) {
-        long long value = fieldstat_counter_get(iter->instance, iter->cube_ids[iter->curr_cube_idx], metric_id, iter->cell_ids[iter->curr_cell_idx]);
-        if (value == -1) {
+        long long value;
+        int tmp_ret = fieldstat_counter_get(iter->instance, iter->cube_ids[iter->curr_cube_idx], metric_id, iter->cell_ids[iter->curr_cell_idx], &value);
+        if (tmp_ret == -1) {
             return NULL;
         }
         ret = malloc(sizeof(struct export_kv_pair));
@@ -639,12 +640,14 @@ void cjson_map_record_metrics(struct cellwise_rec_for_export *tag_field_pair, co
         if (fieldstat_get_metric_type(iter->instance, cube_id, metric_id) != METRIC_TYPE_COUNTER) {
             continue;
         }
-        if (fieldstat_counter_get(iter->instance, cube_id, metric_id, iter->cell_ids[iter->curr_cell_idx]) == -1) { // no value, happens when the two cells in one cube has different metrics
+        long long value;
+        int ret = fieldstat_counter_get(iter->instance, cube_id, metric_id, iter->cell_ids[iter->curr_cell_idx], &value);
+        if (ret == -1) { // no value, happens when the two cells in one cube has different metrics
             continue;
         }
 
         tag_field_pair->metric_name[n_counter_metric] = strdup(fieldstat_get_metric_name(iter->instance, cube_id, metric_id));
-        tag_field_pair->metric_value[n_counter_metric] = fieldstat_counter_get(iter->instance, cube_id, metric_id, iter->cell_ids[iter->curr_cell_idx]);
+        tag_field_pair->metric_value[n_counter_metric] = value;
 
         n_counter_metric++;
     }
diff --git a/src/fieldstat.c b/src/fieldstat.c
index 303d3cd..9b0cc8b 100644
--- a/src/fieldstat.c
+++ b/src/fieldstat.c
@@ -1001,14 +1001,14 @@ struct fieldstat_tag_list *fieldstat_get_shared_tags(const struct fieldstat *ins
     return tag_list;
 }
 
-long long fieldstat_counter_get(const struct fieldstat *instance, int cube_id, int metric_id, int cell_id)
+int fieldstat_counter_get(const struct fieldstat *instance, int cube_id, int metric_id, int cell_id, long long *value)
 {
     const struct metric *metric = fieldstat_find_metric(instance, cube_id, metric_id);
     if (metric == NULL || metric_get_type(metric) != METRIC_TYPE_COUNTER) {
         return -1;
     }
 
-    return metric_counter_get(metric, cell_id);
+    return metric_counter_get(metric, cell_id, value);
 }
 
 double fieldstat_hll_get(const struct fieldstat *instance, int cube_id, int metric_id, int cell_id)
diff --git a/src/metrics/metric.c b/src/metrics/metric.c
index 69c066f..4d37088 100644
--- a/src/metrics/metric.c
+++ b/src/metrics/metric.c
@@ -751,14 +751,15 @@ int metric_counter_set(struct metric *pthis, int cell_id, long long value)
     return 0;
 }
 
-long long metric_counter_get(const struct metric *pthis, int cell_id)
+int metric_counter_get(const struct metric *pthis, int cell_id, long long *value_out)
 {
     const struct metric_measure_data *data = metric_find_one_cell(pthis, cell_id);
     if (data == NULL) {
         return -1;
     }
     const struct metric_counter_or_gauge *counter = data->counter;
-    return counter->value;
+    *value_out = counter->value;
+    return 0;
 }
 
 struct metric *metric_hll_new(const char *name, unsigned char precision)
diff --git a/src/metrics/metric.h b/src/metrics/metric.h
index 6122746..ca48cef 100644
--- a/src/metrics/metric.h
+++ b/src/metrics/metric.h
@@ -23,7 +23,7 @@ void metric_delete_cell(struct metric *pthis, int cell_id);
 struct metric *metric_counter_new(const char *name, enum counter_mode mode);
 void metric_counter_incrby(struct metric *pthis, int cell_id, long long value);
 int metric_counter_set(struct metric *pthis, int cell_id, long long value);
-long long metric_counter_get(const struct metric *pthis, int cell_id);
+int metric_counter_get(const struct metric *pthis, int cell_id, long long *value_out);
 
 struct metric *metric_hll_new(const char *name, unsigned char precision);
 void metric_hll_add(struct metric *pthis, int cell_id, const char *key, size_t key_len);
diff --git a/test/test_empty_tags.cpp b/test/test_empty_tags.cpp
index 9eb0f1d..f531e81 100644
--- a/test/test_empty_tags.cpp
+++ b/test/test_empty_tags.cpp
@@ -56,7 +56,7 @@ TEST(test_empty_tag, add_many_times) // test hash find ok
     fieldstat_counter_incrby(instance, cube_id, metric_id, cell_id, 1);
     fieldstat_counter_incrby(instance, cube_id, metric_id, cell_id, 1);
 
-    EXPECT_EQ(fieldstat_counter_get(instance, cube_id, metric_id, cell_id), 2);
+    EXPECT_EQ(my_fieldstat_counter_get(instance, cube_id, metric_id, cell_id), 2);
 
     fieldstat_free(instance);
 }
@@ -101,7 +101,7 @@ TEST(test_empty_tag, merge)
     free(ret_cell_ids);
     fieldstat_tag_list_arr_free(tag_list, n_cell);
 
-    EXPECT_EQ(fieldstat_counter_get(instance_dst, 0, 0, 0), 2);
+    EXPECT_EQ(my_fieldstat_counter_get(instance_dst, 0, 0, 0), 2);
 
     fieldstat_free(instance_dst);
     fieldstat_free(instance_src);
@@ -136,7 +136,7 @@ TEST(test_empty_tag, merge_topk)
     free(ret_cell_ids);
     fieldstat_tag_list_arr_free(tag_list, n_cell);
 
-    EXPECT_EQ(fieldstat_counter_get(instance_dst, 0, 0, 0), 2);
+    EXPECT_EQ(my_fieldstat_counter_get(instance_dst, 0, 0, 0), 2);
 
     fieldstat_free(instance_dst);
     fieldstat_free(instance_src);
diff --git a/test/test_fuzz_test.cpp b/test/test_fuzz_test.cpp
index c29e3d9..d6604e7 100644
--- a/test/test_fuzz_test.cpp
+++ b/test/test_fuzz_test.cpp
@@ -174,7 +174,7 @@ TEST(Fuzz_test, both_comp_and_topk_cubes_with_merge_and_reset_expecting_correct_
         } else {
             for (size_t j = 0; j < cell_num0; j++) {
                 string cell_key = Fieldstat_tag_list_wrapper(&tags0[j]).to_string();
-                EXPECT_EQ(comp_count[cubes[i]][cell_key], fieldstat_counter_get(instance_in_focus, cubes[i], 0, cells0[j]));
+                EXPECT_EQ(comp_count[cubes[i]][cell_key], my_fieldstat_counter_get(instance_in_focus, cubes[i], 0, cells0[j]));
                 EXPECT_NEAR(comp_hll[cubes[i]][cell_key].size(), fieldstat_hll_get(instance_in_focus, cubes[i], 1, cells0[j]), comp_hll[cubes[i]][cell_key].size() * 0.2);
             }
         }
diff --git a/test/test_merge.cpp b/test/test_merge.cpp
index 2e8cf5d..8c7b8e2 100644
--- a/test/test_merge.cpp
+++ b/test/test_merge.cpp
@@ -65,9 +65,9 @@ TEST(unit_test_merge, test_metric_name_mapping_with_new_metric_on_existing_cube)
     EXPECT_STREQ(fieldstat_get_metric_name(instance_dest, cube_id_dest, 1), "metric_name cube1 cube2");
     EXPECT_STREQ(fieldstat_get_metric_name(instance_dest, cube_id[1], 0), "metric_name cube1 cube2");
 
-    EXPECT_EQ(fieldstat_counter_get(instance_dest, cube_id_dest, 0, 0), 2); // shared name
-    EXPECT_EQ(fieldstat_counter_get(instance_dest, cube_id_dest, 1, 0), 1); // metric_name cube1 cube2 on cube1
-    EXPECT_EQ(fieldstat_counter_get(instance_dest, cube_id[1], 0, 0), 3); // metric_name cube1 cube2 on cube2
+    EXPECT_EQ(my_fieldstat_counter_get(instance_dest, cube_id_dest, 0, 0), 2); // shared name
+    EXPECT_EQ(my_fieldstat_counter_get(instance_dest, cube_id_dest, 1, 0), 1); // metric_name cube1 cube2 on cube1
+    EXPECT_EQ(my_fieldstat_counter_get(instance_dest, cube_id[1], 0, 0), 3); // metric_name cube1 cube2 on cube2
 
     fieldstat_free(instance);
     fieldstat_free(instance_dest);
@@ -153,7 +153,7 @@ TEST(unit_test_merge, new_cell_on_existing_cube_and_metric_comprehensive)
     free(cube_id_dest);
     int ret_metric_id = fieldstat_get_max_metric_id(instance, ret_cube_id);
     EXPECT_EQ(ret_metric_id, 0);
-    long long measure = fieldstat_counter_get(instance, cube_id, metric_id, cell_id);
+    long long measure = my_fieldstat_counter_get(instance, cube_id, metric_id, cell_id);
     EXPECT_EQ(measure, 10086);
 
     int *ret_cell_ids = NULL;
@@ -190,7 +190,7 @@ TEST(unit_test_merge, merge_existing_cell_on_existing_cube_and_metric_comprehens
     free(cube_id_dest);
     int ret_metric_id = fieldstat_get_max_metric_id(instance_dest, ret_cube_id);
     EXPECT_EQ(ret_metric_id, 0);
-    long long measure = fieldstat_counter_get(instance_dest, cube_id, metric_id, 0);
+    long long measure = my_fieldstat_counter_get(instance_dest, cube_id, metric_id, 0);
     EXPECT_EQ(measure, 10);
 
     fieldstat_free(instance);
@@ -313,7 +313,7 @@ TEST(unit_test_merge, new_cell_on_existing_cube_and_metric_topk)
     free(cube_id_dest);
     int ret_metric_id = fieldstat_get_max_metric_id(instance, ret_cube_id);
     EXPECT_EQ(ret_metric_id, 0);
-    long long measure = fieldstat_counter_get(instance, cube_id, metric_id, cell_id);
+    long long measure = my_fieldstat_counter_get(instance, cube_id, metric_id, cell_id);
     EXPECT_EQ(measure, 10086);
 
     int *ret_cell_ids = NULL;
@@ -356,7 +356,7 @@ TEST(unit_test_merge, merge_existing_cell_on_existing_cube_and_metric_topk)
     size_t n_cell = 0;
     fieldstat_get_cells(instance_dest, ret_cube_id, ret_metric_id, &ret_cell_ids, &tag_list, &n_cell);
     EXPECT_EQ(n_cell, 1);
-    long long measure = fieldstat_counter_get(instance_dest, cube_id, metric_id, ret_cell_ids[0]);
+    long long measure = my_fieldstat_counter_get(instance_dest, cube_id, metric_id, ret_cell_ids[0]);
     EXPECT_EQ(measure, 10);
 
     free(ret_cell_ids);
@@ -616,7 +616,7 @@ TEST(unit_test_merge, exception_test_given_cell_added_but_no_metric_operation_gi
     size_t n_cell = 0;
     fieldstat_get_cells(instance2, cube_id, metric_id, &cell_ids, &tag_list, &n_cell);
     EXPECT_TRUE(n_cell == 0);
-    EXPECT_EQ(fieldstat_counter_get(instance2, cube_id, metric_id, cell_id), -1);
+    EXPECT_EQ(my_fieldstat_counter_get(instance2, cube_id, metric_id, cell_id), -1);
 
     fieldstat_free(instance);
     fieldstat_free(instance2);
@@ -642,7 +642,7 @@ TEST(unit_test_merge, exception_test_given_cell_added_but_no_metric_operation_gi
     size_t n_cell = 0;
     fieldstat_get_cells(instance2, cube_id, metric_id, &cell_ids, &tag_list, &n_cell);
     EXPECT_EQ(n_cell, 1);
-    EXPECT_EQ(fieldstat_counter_get(instance2, cube_id, metric_id, cell_id), 123);
+    EXPECT_EQ(my_fieldstat_counter_get(instance2, cube_id, metric_id, cell_id), 123);
 
     fieldstat_free(instance);
     fieldstat_free(instance2);
diff --git a/test/test_metric_counter.cpp b/test/test_metric_counter.cpp
index 77b4991..23e02e7 100644
--- a/test/test_metric_counter.cpp
+++ b/test/test_metric_counter.cpp
@@ -57,7 +57,7 @@ TEST(metric_test_counter, simple_register_and_query_counter)
     fieldstat_counter_incrby(instance, 0, 0, 0, 86);
 
     test_assert_standard_instance(instance);
-    EXPECT_EQ(fieldstat_counter_get(instance, 0, 0, 0), 10086);
+    EXPECT_EQ(my_fieldstat_counter_get(instance, 0, 0, 0), 10086);
 
     fieldstat_free(instance);
 }
@@ -79,7 +79,7 @@ TEST(metric_test_counter, serialize_and_merge_counter)
     // query
     test_assert_standard_instance(instance_total);
 
-    long long measure = fieldstat_counter_get(instance_total, 0, 0, 0);
+    long long measure = my_fieldstat_counter_get(instance_total, 0, 0, 0);
     EXPECT_EQ(measure, -9900);
 
     fieldstat_free(instance);
@@ -112,7 +112,7 @@ TEST(metric_test_counter, serialization_and_merge_counter_twice_with_reset)
     fieldstat_merge(instance_total, instance_from_blob);
 
     test_assert_standard_instance(instance_total);
-    long long measure = fieldstat_counter_get(instance_total, 0, 0, 0);
+    long long measure = my_fieldstat_counter_get(instance_total, 0, 0, 0);
     EXPECT_EQ(measure, 10086 + 4);
 
     fieldstat_free(instance);
@@ -128,7 +128,7 @@ TEST(metric_test_counter, simple_register_and_query_gauge)
     fieldstat_counter_set(instance, 0, 0, 0, 86);
 
     test_assert_standard_instance(instance);
-    EXPECT_EQ(fieldstat_counter_get(instance, 0, 0, 0), 86);
+    EXPECT_EQ(my_fieldstat_counter_get(instance, 0, 0, 0), 86);
 
     fieldstat_free(instance);
 }
@@ -149,7 +149,7 @@ TEST(metric_test_counter, serialize_and_merge_gauge)
 
     test_assert_standard_instance(instance_total);
 
-    long long measure = fieldstat_counter_get(instance_total, 0, 0, 0);
+    long long measure = my_fieldstat_counter_get(instance_total, 0, 0, 0);
     EXPECT_EQ(measure, 10);
 
     fieldstat_free(instance);
@@ -182,7 +182,7 @@ TEST(metric_test_counter, serialization_and_merge_gauge_twice_with_reset)
     fieldstat_merge(instance_total, instance_from_blob);
 
     test_assert_standard_instance(instance_total);
-    long long measure = fieldstat_counter_get(instance_total, 0, 0, 0);
+    long long measure = my_fieldstat_counter_get(instance_total, 0, 0, 0);
     EXPECT_EQ(measure, 1234);
 
     fieldstat_free(instance);
@@ -236,7 +236,7 @@ TEST(metric_test_counter, topk_add_and_test_accuracy)
 
         EXPECT_STREQ(key.c_str(), "elephant ");
 
-        error += abs(fieldstat_counter_get(instance, 0, 0, ret_cell_ids[i]) - flow_cnt[key + value]);
+        error += abs(my_fieldstat_counter_get(instance, 0, 0, ret_cell_ids[i]) - flow_cnt[key + value]);
     }
     printf("topk_add_and_test_accuracy Mean ratio e: %lld\n", error);
     EXPECT_LT(error, tag_list_num * 0.005);
diff --git a/test/test_register_and_reset.cpp b/test/test_register_and_reset.cpp
index 1a76086..12bfc2c 100644
--- a/test/test_register_and_reset.cpp
+++ b/test/test_register_and_reset.cpp
@@ -85,7 +85,7 @@ TEST(test_register, reset_and_try_to_query_cell)
 
     fieldstat_reset(instance);
     EXPECT_EQ(fieldstat_get_max_metric_id(instance, cube_id), 0);
-    EXPECT_EQ(fieldstat_counter_get(instance, cube_id, metric_id, cell_id), -1);
+    EXPECT_EQ(my_fieldstat_counter_get(instance, cube_id, metric_id, cell_id), -1);
 
     fieldstat_free(instance);
 }
@@ -108,7 +108,7 @@ TEST(test_register, register_many_cubes)
     }
 
     for (int i = 0; i < registered_cube; i++) {
-        long long result = fieldstat_counter_get(instance, i, 0, 0);
+        long long result = my_fieldstat_counter_get(instance, i, 0, 0);
         EXPECT_EQ(result, i);
     }
 
@@ -129,7 +129,7 @@ TEST(test_register, add_long_tagged_cells)
     int metric_id = fieldstat_register_counter(instance, cube_id, "counter", COUNTER_MERGE_BY_SUM);
     fieldstat_counter_incrby(instance, cube_id, metric_id, cell_id, 10086);
 
-    EXPECT_EQ(fieldstat_counter_get(instance, cube_id, metric_id, cell_id), 10086);
+    EXPECT_EQ(my_fieldstat_counter_get(instance, cube_id, metric_id, cell_id), 10086);
 
     fieldstat_free(instance);
 }
@@ -228,9 +228,9 @@ TEST(test_register, unregister_cube_on_wrong_instance)
 
     fieldstat_merge(instance_dst, instance);
 
-    long long val_deleted_once = fieldstat_counter_get(instance_dst, cube_id, metric_id, cell_id);
+    long long val_deleted_once = my_fieldstat_counter_get(instance_dst, cube_id, metric_id, cell_id);
     EXPECT_EQ(val_deleted_once, 1);
-    long long val_merged_twice = fieldstat_counter_get(instance_dst, cube_id2, metric_id2, cell_id2);
+    long long val_merged_twice = my_fieldstat_counter_get(instance_dst, cube_id2, metric_id2, cell_id2);
     EXPECT_EQ(val_merged_twice, 2);
 
     fieldstat_free(instance);
@@ -253,7 +253,7 @@ TEST(test_register, register_many_cells_on_unlimited_sized_cube)
     }
 
     for (int i = 0; i < 10000; i++) {
-        EXPECT_EQ(fieldstat_counter_get(instance, cube_id, metric_id, i), 1);
+        EXPECT_EQ(my_fieldstat_counter_get(instance, cube_id, metric_id, i), 1);
     }
 
     fieldstat_free(instance);
@@ -271,7 +271,7 @@ TEST(test_register, unregister_cell)
 
     int cell_id_removed = fieldstat_cube_remove(instance, cube_id, &TEST_TAG_INT, 1);
     EXPECT_EQ(cell_id_removed, cell_id1);
-    EXPECT_EQ(fieldstat_counter_get(instance, cube_id, metric_id, cell_id1), -1);
+    EXPECT_EQ(my_fieldstat_counter_get(instance, cube_id, metric_id, cell_id1), -1);
     
     int *cell_ids = NULL;
     struct fieldstat_tag_list *tag_list = NULL;
diff --git a/test/test_serialize.cpp b/test/test_serialize.cpp
index 62e46b1..9ce128a 100644
--- a/test/test_serialize.cpp
+++ b/test/test_serialize.cpp
@@ -29,7 +29,7 @@ TEST(unit_test_serialize, serialize_and_deserialize_fieldstat_instance_comprehen
     EXPECT_EQ(ret_cell_id, 0);
     int ret_metric_id = fieldstat_get_max_metric_id(instance2, ret_cell_id);
     EXPECT_EQ(ret_metric_id, 0);
-    long long measure = fieldstat_counter_get(instance2, cube_id, metric_id, cell_id1);
+    long long measure = my_fieldstat_counter_get(instance2, cube_id, metric_id, cell_id1);
     EXPECT_EQ(measure, 10086);
     const char *name = fieldstat_get_metric_name(instance2, cube_id, metric_id);
     EXPECT_STREQ(name, "czz_test counter metric");
@@ -78,7 +78,7 @@ TEST(unit_test_serialize, serialize_and_deserialize_fieldstat_instance_topk)
     EXPECT_EQ(ret_cell_id, 0);
     int ret_metric_id = fieldstat_get_max_metric_id(instance2, ret_cell_id);
     EXPECT_EQ(ret_metric_id, 0);
-    long long measure = fieldstat_counter_get(instance2, cube_id, metric_id, cell_id1);
+    long long measure = my_fieldstat_counter_get(instance2, cube_id, metric_id, cell_id1);
     EXPECT_EQ(measure, 10086);
     const char *name = fieldstat_get_metric_name(instance2, cube_id, metric_id);
     EXPECT_STREQ(name, "czz_test counter metric");
diff --git a/test/utils.cpp b/test/utils.cpp
index b53e4e4..ec5abf9 100644
--- a/test/utils.cpp
+++ b/test/utils.cpp
@@ -293,3 +293,10 @@ double test_cal_topk_accuracy(vector<struct Fieldstat_tag_list_wrapper *> &test_
     double accuracy = (double)correct / test_result.size();
     return accuracy;
 }
+
+long long my_fieldstat_counter_get(const struct fieldstat *instance, int cube_id, int metric_id, int cell_id)
+{
+    long long value;
+    fieldstat_counter_get(instance, cube_id, metric_id, cell_id, &value);
+    return value;
+}
\ No newline at end of file
diff --git a/test/utils.hpp b/test/utils.hpp
index 5da5daf..5734bf6 100644
--- a/test/utils.hpp
+++ b/test/utils.hpp
@@ -38,4 +38,7 @@ private:
 };
 
 
-double test_cal_topk_accuracy(std::vector<struct Fieldstat_tag_list_wrapper *> &test_result, std::unordered_map<std::string, int> &expected_count);
\ No newline at end of file
+double test_cal_topk_accuracy(std::vector<struct Fieldstat_tag_list_wrapper *> &test_result, std::unordered_map<std::string, int> &expected_count);
+
+// after we change fieldstat_counter_get return a error code in, all the tests should change correspondingly, so just use a adapter aliasing the old function
+long long my_fieldstat_counter_get(const struct fieldstat *instance, int cube_id, int metric_id, int cell_id);
\ No newline at end of file