fix c/python statistic

Author: hongzhi-gao

cpp/src/cwrapper/tsfile_cwrapper.cc

@@ -105,49 +105,86 @@ typedef struct device_schema {
 } DeviceSchema;
 
 /**
- * @brief Aggregated statistic for one timeseries (subset of C++ Statistic).
+ * @brief Common header for all statistic variants (first member of each
+ * TsFile*Statistic struct; also aliases the start of TimeseriesStatistic::u).
  *
- * String pointers str_* are allocated with malloc; freed by
- * tsfile_free_device_timeseries_metadata_map (do not free individually).
+ * When @p has_statistic is false, @p type is undefined. Otherwise @p type
+ * selects which @ref TimeseriesStatisticUnion member is active (INT32/DATE/
+ * INT64/TIMESTAMP share @c int_s). @c sum exists only on @c bool_s, @c int_s,
+ * and @c float_s. Heap strings in string_s/text_s are
+ * freed by tsfile_free_device_timeseries_metadata_map only.
  */
-typedef struct TimeseriesStatistic {
+typedef struct TsFileStatisticBase {
     bool has_statistic;
+    TSDataType type;
     int32_t row_count;
     int64_t start_time;
     int64_t end_time;
-    /** True when @p sum is meaningful (numeric / boolean aggregate types). */
-    bool sum_valid;
-    /** Sum when sum_valid; boolean uses sum of true as int-like aggregate. */
+} TsFileStatisticBase;
+
+typedef struct TsFileBoolStatistic {
+    TsFileStatisticBase base;
     double sum;
+    bool first_bool;
+    bool last_bool;
+} TsFileBoolStatistic;
 
-    /** INT32, DATE, INT64, TIMESTAMP: min/max/first/last in int64_t form. */
-    bool int_range_valid;
+typedef struct TsFileIntStatistic {
+    TsFileStatisticBase base;
+    double sum;
     int64_t min_int64;
     int64_t max_int64;
     int64_t first_int64;
     int64_t last_int64;
+} TsFileIntStatistic;
 
-    /** FLOAT, DOUBLE: min/max/first/last. */
-    bool float_range_valid;
+typedef struct TsFileFloatStatistic {
+    TsFileStatisticBase base;
+    double sum;
     double min_float64;
     double max_float64;
     double first_float64;
     double last_float64;
+} TsFileFloatStatistic;
 
-    /** BOOLEAN: first/last sample values. */
-    bool bool_ext_valid;
-    bool first_bool;
-    bool last_bool;
-
-    /** STRING: min/max lexicographic; TEXT: first/last only (min/max unused).
-     */
-    bool str_ext_valid;
+typedef struct TsFileStringStatistic {
+    TsFileStatisticBase base;
     char* str_min;
     char* str_max;
     char* str_first;
     char* str_last;
+} TsFileStringStatistic;
+
+typedef struct TsFileTextStatistic {
+    TsFileStatisticBase base;
+    char* str_first;
+    char* str_last;
+} TsFileTextStatistic;
+
+/**
+ * @brief One of the typed layouts; active member follows @c base.type.
+ */
+typedef union TimeseriesStatisticUnion {
+    TsFileBoolStatistic bool_s;
+    TsFileIntStatistic int_s;
+    TsFileFloatStatistic float_s;
+    TsFileStringStatistic string_s;
+    TsFileTextStatistic text_s;
+} TimeseriesStatisticUnion;
+
+/**
+ * @brief Aggregated statistic for one timeseries (subset of C++ Statistic).
+ *
+ * Read common fields via @c tsfile_statistic_base(s). Type-specific fields
+ * via @c s->u.int_s, @c s->u.float_s, etc., per @c base.type.
+ */
+typedef struct TimeseriesStatistic {
+    TimeseriesStatisticUnion u;
 } TimeseriesStatistic;
 
+/** Pointer to the common header at the start of @p s->u (any active arm). */
+#define tsfile_statistic_base(s) ((TsFileStatisticBase*)&(s)->u)
+
 /**
  * @brief One measurement's metadata as exposed to C.
  */
@@ -161,24 +198,24 @@ typedef struct TimeseriesMetadata {
 /**
  * @brief Device identity from IDeviceID (path, table name, segments).
  *
- * Heap fields are freed by tsfile_device_details_free_contents or
- * tsfile_free_device_details_array, or as part of
+ * Heap fields are freed by tsfile_device_id_free_contents or
+ * tsfile_free_device_id_array, or as part of
  * tsfile_free_device_timeseries_metadata_map for entries.
  */
-typedef struct TsDeviceDetails {
+typedef struct DeviceID {
     char* path;
     char* table_name;
     uint32_t segment_count;
     char** segments;
-} TsDeviceDetails;
+} DeviceID;
 
 /**
- * @brief One device's timeseries metadata list plus TsDeviceDetails.
+ * @brief One device's timeseries metadata list plus DeviceID.
  *
  * @p device heap fields freed by tsfile_free_device_timeseries_metadata_map.
  */
 typedef struct DeviceTimeseriesMetadataEntry {
-    TsDeviceDetails device;
+    DeviceID device;
     TimeseriesMetadata* timeseries;
     uint32_t timeseries_count;
 } DeviceTimeseriesMetadataEntry;
@@ -193,7 +230,7 @@ typedef struct DeviceTimeseriesMetadataMap {
 } DeviceTimeseriesMetadataMap;
 
 /** Frees path, table_name, and segments inside @p d; zeros @p d. */
-void tsfile_device_details_free_contents(TsDeviceDetails* d);
+void tsfile_device_id_free_contents(DeviceID* d);
 
 typedef struct result_set_meta_data {
     char** column_names;
@@ -411,14 +448,13 @@ ERRNO tsfile_reader_close(TsFileReader reader);
  * @brief Lists all devices (path, table name, segments from IDeviceID).
  *
  * @param out_devices [out] Allocated array; caller frees with
- * tsfile_free_device_details_array.
+ * tsfile_free_device_id_array.
  */
 ERRNO tsfile_reader_get_all_devices(TsFileReader reader,
-                                    TsDeviceDetails** out_devices,
+                                    DeviceID** out_devices,
                                     uint32_t* out_length);
 
-void tsfile_free_device_details_array(TsDeviceDetails* details,
-                                      uint32_t length);
+void tsfile_free_device_id_array(DeviceID* devices, uint32_t length);
 
 /**
  * @brief Timeseries metadata for all devices in the file.
@@ -434,7 +470,7 @@ ERRNO tsfile_reader_get_timeseries_metadata_all(
  * For each entry, @p path must be non-NULL (canonical device path).
  */
 ERRNO tsfile_reader_get_timeseries_metadata_for_devices(
-    TsFileReader reader, const TsDeviceDetails* devices, uint32_t length,
+    TsFileReader reader, const DeviceID* devices, uint32_t length,
     DeviceTimeseriesMetadataMap* out_map);
 
 void tsfile_free_device_timeseries_metadata_map(

cpp/src/cwrapper/tsfile_cwrapper.h

@@ -65,7 +65,7 @@ TEST_F(CWrapperMetadataTest, GetAllDevicesAndMetadataWithStatistic) {
     ASSERT_EQ(RET_OK, code);
     ASSERT_NE(nullptr, reader);
 
-    TsDeviceDetails* details = nullptr;
+    DeviceID* details = nullptr;
     uint32_t n_det = 0;
     ASSERT_EQ(RET_OK, tsfile_reader_get_all_devices(reader, &details, &n_det));
     ASSERT_EQ(1u, n_det);
@@ -77,7 +77,7 @@ TEST_F(CWrapperMetadataTest, GetAllDevicesAndMetadataWithStatistic) {
     ASSERT_NE(nullptr, details[0].segments);
     EXPECT_STREQ("root.sg", details[0].segments[0]);
     EXPECT_STREQ("d1", details[0].segments[1]);
-    tsfile_free_device_details_array(details, n_det);
+    tsfile_free_device_id_array(details, n_det);
 
     DeviceTimeseriesMetadataMap map{};
     ASSERT_EQ(RET_OK, tsfile_reader_get_timeseries_metadata_all(reader, &map));
@@ -95,17 +95,17 @@ TEST_F(CWrapperMetadataTest, GetAllDevicesAndMetadataWithStatistic) {
     TimeseriesMetadata& tm = map.entries[0].timeseries[0];
     ASSERT_STREQ(m_int, tm.measurement_name);
     ASSERT_EQ(TS_DATATYPE_INT32, tm.data_type);
-    ASSERT_TRUE(tm.statistic.has_statistic);
-    EXPECT_EQ(3, tm.statistic.row_count);
-    EXPECT_EQ(1, tm.statistic.start_time);
-    EXPECT_EQ(3, tm.statistic.end_time);
-    ASSERT_TRUE(tm.statistic.sum_valid);
-    EXPECT_DOUBLE_EQ(60.0, tm.statistic.sum);
-    ASSERT_TRUE(tm.statistic.int_range_valid);
-    EXPECT_EQ(10, tm.statistic.min_int64);
-    EXPECT_EQ(30, tm.statistic.max_int64);
-    EXPECT_EQ(10, tm.statistic.first_int64);
-    EXPECT_EQ(30, tm.statistic.last_int64);
+    TsFileStatisticBase* sb = tsfile_statistic_base(&tm.statistic);
+    ASSERT_TRUE(sb->has_statistic);
+    EXPECT_EQ(3, sb->row_count);
+    EXPECT_EQ(1, sb->start_time);
+    EXPECT_EQ(3, sb->end_time);
+    EXPECT_DOUBLE_EQ(60.0, tm.statistic.u.int_s.sum);
+    ASSERT_EQ(TS_DATATYPE_INT32, sb->type);
+    EXPECT_EQ(10, tm.statistic.u.int_s.min_int64);
+    EXPECT_EQ(30, tm.statistic.u.int_s.max_int64);
+    EXPECT_EQ(10, tm.statistic.u.int_s.first_int64);
+    EXPECT_EQ(30, tm.statistic.u.int_s.last_int64);
 
     tsfile_free_device_timeseries_metadata_map(&map);
 
@@ -115,7 +115,7 @@ TEST_F(CWrapperMetadataTest, GetAllDevicesAndMetadataWithStatistic) {
     EXPECT_EQ(0u, empty.device_count);
     EXPECT_EQ(nullptr, empty.entries);
 
-    TsDeviceDetails q{};
+    DeviceID q{};
     q.path = const_cast<char*>(device);
     q.table_name = nullptr;
     q.segment_count = 0;
@@ -168,12 +168,12 @@ TEST_F(CWrapperMetadataTest, GetTimeseriesMetadataBooleanStatistic) {
     TimeseriesMetadata& tm = map.entries[0].timeseries[0];
     ASSERT_STREQ(m_b, tm.measurement_name);
     ASSERT_EQ(TS_DATATYPE_BOOLEAN, tm.data_type);
-    ASSERT_TRUE(tm.statistic.has_statistic);
-    ASSERT_TRUE(tm.statistic.sum_valid);
-    EXPECT_DOUBLE_EQ(2.0, tm.statistic.sum);
-    ASSERT_TRUE(tm.statistic.bool_ext_valid);
-    EXPECT_TRUE(tm.statistic.first_bool);
-    EXPECT_TRUE(tm.statistic.last_bool);
+    TsFileStatisticBase* sb = tsfile_statistic_base(&tm.statistic);
+    ASSERT_TRUE(sb->has_statistic);
+    EXPECT_DOUBLE_EQ(2.0, tm.statistic.u.bool_s.sum);
+    ASSERT_EQ(TS_DATATYPE_BOOLEAN, sb->type);
+    EXPECT_TRUE(tm.statistic.u.bool_s.first_bool);
+    EXPECT_TRUE(tm.statistic.u.bool_s.last_bool);
 
     tsfile_free_device_timeseries_metadata_map(&map);
     ASSERT_EQ(RET_OK, tsfile_reader_close(reader));
@@ -220,16 +220,17 @@ TEST_F(CWrapperMetadataTest, GetTimeseriesMetadataStringStatistic) {
     TimeseriesMetadata& tm = map.entries[0].timeseries[0];
     ASSERT_STREQ(m_str, tm.measurement_name);
     ASSERT_EQ(TS_DATATYPE_STRING, tm.data_type);
-    ASSERT_TRUE(tm.statistic.has_statistic);
-    ASSERT_TRUE(tm.statistic.str_ext_valid);
-    ASSERT_NE(nullptr, tm.statistic.str_min);
-    ASSERT_NE(nullptr, tm.statistic.str_max);
-    ASSERT_NE(nullptr, tm.statistic.str_first);
-    ASSERT_NE(nullptr, tm.statistic.str_last);
-    EXPECT_STREQ("aa", tm.statistic.str_min);
-    EXPECT_STREQ("cc", tm.statistic.str_max);
-    EXPECT_STREQ("aa", tm.statistic.str_first);
-    EXPECT_STREQ("bb", tm.statistic.str_last);
+    TsFileStatisticBase* sb = tsfile_statistic_base(&tm.statistic);
+    ASSERT_TRUE(sb->has_statistic);
+    ASSERT_EQ(TS_DATATYPE_STRING, sb->type);
+    ASSERT_NE(nullptr, tm.statistic.u.string_s.str_min);
+    ASSERT_NE(nullptr, tm.statistic.u.string_s.str_max);
+    ASSERT_NE(nullptr, tm.statistic.u.string_s.str_first);
+    ASSERT_NE(nullptr, tm.statistic.u.string_s.str_last);
+    EXPECT_STREQ("aa", tm.statistic.u.string_s.str_min);
+    EXPECT_STREQ("cc", tm.statistic.u.string_s.str_max);
+    EXPECT_STREQ("aa", tm.statistic.u.string_s.str_first);
+    EXPECT_STREQ("bb", tm.statistic.u.string_s.str_last);
 
     tsfile_free_device_timeseries_metadata_map(&map);
     ASSERT_EQ(RET_OK, tsfile_reader_close(reader));
@@ -250,7 +251,7 @@ TEST_F(CWrapperMetadataTest, GetTimeseriesMetadataNullDevicePath) {
     TsFileReader reader = tsfile_reader_new(filename, &code);
     ASSERT_EQ(RET_OK, code);
 
-    TsDeviceDetails bad{};
+    DeviceID bad{};
     bad.path = nullptr;
     bad.table_name = nullptr;
     bad.segment_count = 0;

cpp/test/cwrapper/cwrapper_metadata_test.cc

@@ -22,7 +22,12 @@
 
 from tsfile import Field, RowRecord, TimeseriesSchema, TsFileReader, TsFileWriter
 from tsfile import TSDataType
-from tsfile.schema import DeviceDetails
+from tsfile.schema import (
+    BoolTimeseriesStatistic,
+    DeviceID,
+    IntTimeseriesStatistic,
+    StringTimeseriesStatistic,
+)
 
 
 def test_get_all_devices_segments():
@@ -100,21 +105,20 @@ def test_get_all_devices_and_timeseries_metadata_statistic():
         assert m.measurement_name == "m_int"
         assert m.data_type == TSDataType.INT32
         st = m.statistic
+        assert isinstance(st, IntTimeseriesStatistic)
         assert st.has_statistic
         assert st.row_count == 3
         assert st.start_time == 1
         assert st.end_time == 3
-        assert st.sum_valid
         assert st.sum == pytest.approx(60.0)
-        assert st.int_range_valid
         assert st.min_int64 == 10
         assert st.max_int64 == 30
         assert st.first_int64 == 10
         assert st.last_int64 == 30
 
         assert reader.get_timeseries_metadata([]) == {}
 
-        sub = reader.get_timeseries_metadata([DeviceDetails(device, "", ())])
+        sub = reader.get_timeseries_metadata([DeviceID(device, None, ())])
         assert device in sub
         assert len(sub[device].timeseries) == 1
 
@@ -153,10 +157,9 @@ def test_get_timeseries_metadata_boolean_statistic():
     try:
         meta_all = reader.get_timeseries_metadata(None)
         st = meta_all[device].timeseries[0].statistic
+        assert isinstance(st, BoolTimeseriesStatistic)
         assert st.has_statistic
-        assert st.sum_valid
         assert st.sum == pytest.approx(2.0)
-        assert st.bool_ext_valid
         assert st.first_bool is True
         assert st.last_bool is True
     finally:
@@ -195,8 +198,8 @@ def test_get_timeseries_metadata_string_statistic():
         assert m.measurement_name == "m_str"
         assert m.data_type == TSDataType.STRING
         st = m.statistic
+        assert isinstance(st, StringTimeseriesStatistic)
         assert st.has_statistic
-        assert st.str_ext_valid
         assert st.str_min == "aa"
         assert st.str_max == "cc"
         assert st.str_first == "aa"