| <!-- |
| |
| Licensed to the Apache Software Foundation (ASF) under one |
| or more contributor license agreements. See the NOTICE file |
| distributed with this work for additional information |
| regarding copyright ownership. The ASF licenses this file |
| to you under the Apache License, Version 2.0 (the |
| "License"); you may not use this file except in compliance |
| with the License. You may obtain a copy of the License at |
| |
| http://www.apache.org/licenses/LICENSE-2.0 |
| |
| Unless required by applicable law or agreed to in writing, |
| software distributed under the License is distributed on an |
| "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| KIND, either express or implied. See the License for the |
| specific language governing permissions and limitations |
| under the License. |
| |
| --> |
| # Interface definition - C |
| |
| |
| |
| ## Schema |
| |
| ```C |
| typedef enum { |
| TS_DATATYPE_BOOLEAN = 0, |
| TS_DATATYPE_INT32 = 1, |
| TS_DATATYPE_INT64 = 2, |
| TS_DATATYPE_FLOAT = 3, |
| TS_DATATYPE_DOUBLE = 4, |
| TS_DATATYPE_TEXT = 5, |
| TS_DATATYPE_TIMESTAMP = 8, |
| TS_DATATYPE_DATE = 9, |
| TS_DATATYPE_BLOB = 10, |
| TS_DATATYPE_STRING = 11, |
| TS_DATATYPE_INVALID = 255 |
| } TSDataType; |
| |
| // Value encoding. |
| typedef enum { |
| TS_ENCODING_PLAIN = 0, |
| TS_ENCODING_DICTIONARY = 1, |
| TS_ENCODING_RLE = 2, |
| TS_ENCODING_TS_2DIFF = 4, |
| TS_ENCODING_GORILLA = 8, |
| TS_ENCODING_ZIGZAG = 9, |
| TS_ENCODING_SPRINTZ = 12, |
| TS_ENCODING_INVALID = 255 |
| } TSEncoding; |
| |
| // Compression type. LZ4 is the default. |
| typedef enum { |
| TS_COMPRESSION_UNCOMPRESSED = 0, |
| TS_COMPRESSION_SNAPPY = 1, |
| TS_COMPRESSION_GZIP = 2, |
| TS_COMPRESSION_LZO = 3, |
| TS_COMPRESSION_LZ4 = 7, |
| TS_COMPRESSION_INVALID = 255 |
| } CompressionType; |
| |
| typedef enum column_category { |
| TAG = 0, |
| FIELD = 1, |
| ATTRIBUTE = 2, |
| TIME = 3 |
| } ColumnCategory; |
| |
| // ColumnSchema: Represents the schema of a single column, |
| // including its name, data type, and category. |
| // On write, encoding/compression for columns follow the global defaults |
| // (see "Configuration" below). |
| typedef struct column_schema { |
| char* column_name; |
| TSDataType data_type; |
| ColumnCategory column_category; |
| } ColumnSchema; |
| |
| // TableSchema: Defines the schema of a table, |
| // including its name and a list of column schemas. |
| typedef struct table_schema { |
| char* table_name; |
| ColumnSchema* column_schemas; |
| int column_num; |
| } TableSchema; |
| |
| // ResultSetMetaData: Contains metadata for a result set, |
| // such as column names and their data types. |
| typedef struct result_set_meta_data { |
| char** column_names; |
| TSDataType* data_types; |
| int column_num; |
| } ResultSetMetaData; |
| ``` |
| |
| > `ColumnSchema` does not carry encoding/compression: on write, columns follow the |
| > global defaults (see [Configuration](#configuration-encoding--compression)); on |
| > read, each column is decoded with the file's actual settings. |
| |
| |
| ## Write Interface |
| |
| ### TsFile WriteFile Create/Close |
| |
| ```C |
| /** |
| * @brief Creates a file for writing. |
| * |
| * @param pathname Target file to create. |
| * @param err_code [out] RET_OK(0), or error code in errno_define_c.h. |
| * |
| * @return WriteFile Valid handle on success. |
| * |
| * @note Call free_write_file() to release resources. |
| * @note Before call free_write_file(), make sure TsFileWriter has been closed. |
| */ |
| |
| WriteFile write_file_new(const char* pathname, ERRNO* err_code); |
| |
| void free_write_file(WriteFile* write_file); |
| ``` |
| |
| ### TsFile Writer Create/Close |
| |
| When creating a TsFile Writer, you specify a `WriteFile` and a `TableSchema`. As |
| you write, data is buffered in memory and automatically flushed to disk once the |
| buffered size exceeds `memory_threshold` bytes. `tsfile_writer_new` uses the |
| default (128 MB); `tsfile_writer_new_with_memory_threshold` lets you override it |
| — a larger value buffers more before flushing (more memory, larger chunk groups), |
| a smaller value flushes more often. |
| |
| ```C |
| /** |
| * @brief Creates a TsFileWriter for writing a TsFile. |
| * |
| * @param file Target file where the table data will be written. |
| * @param schema Table schema definition. |
| * - Ownership: Should be freed by the caller. |
| * @param err_code [out] RET_OK(0), or error code in errno_define_c.h. |
| * |
| * @return TsFileWriter Valid handle on success, NULL on failure. |
| * |
| * @note Call tsfile_writer_close() to release resources. |
| */ |
| TsFileWriter tsfile_writer_new(WriteFile file, TableSchema* schema, |
| ERRNO* err_code); |
| |
| /** |
| * @brief Creates a TsFileWriter for writing a TsFile. |
| * |
| * @param file Target file where the table data will be written. |
| * @param schema Table schema definition. |
| * - Ownership: Should be freed by the caller. |
| * @param memory_threshold When the size of written data exceeds |
| * this value, the data will be automatically flushed to the disk. |
| * @param err_code [out] RET_OK(0), or error code in errno_define_c.h. |
| * |
| * @return TsFileWriter Valid handle on success, NULL on failure. |
| * |
| * @note Call tsfile_writer_close() to release resources. |
| */ |
| TsFileWriter tsfile_writer_new_with_memory_threshold(WriteFile file, |
| TableSchema* schema, |
| uint64_t memory_threshold, |
| ERRNO* err_code); |
| |
| /** |
| * @brief Releases resources associated with a TsFileWriter. |
| * |
| * @param writer [in] Writer handle obtained from tsfile_writer_new(). |
| * After call: handle becomes invalid and must not be reused. |
| * @return ERRNO - RET_OK(0) on success, or error code in errno_define_c.h. |
| */ |
| ERRNO tsfile_writer_close(TsFileWriter writer); |
| ``` |
| |
| |
| |
| ### Tablet Create/Close/Insert data |
| |
| You can use Tablet to insert data into TsFile in batches, and you need to release the space occupied by the Tablet after use. |
| |
| ```C |
| /** |
| * @brief Creates a Tablet for batch data. |
| * |
| * @param column_name_list [in] Column names array. Size=column_num. |
| * @param data_types [in] Data types array. Size=column_num. |
| * @param column_num [in] Number of columns. Must be ≥1. |
| * @param max_rows [in] Pre-allocated row capacity. Must be ≥1. |
| * @return Tablet Valid handle. |
| * @note Call free_tablet() to release resources. |
| */ |
| Tablet tablet_new(char** column_name_list, TSDataType* data_types, |
| uint32_t column_num, uint32_t max_rows); |
| /** |
| * @brief Gets current row count in the Tablet. |
| * |
| * @param tablet [in] Valid Tablet handle. |
| * @return uint32_t Row count (0 to max_rows-1). |
| */ |
| uint32_t tablet_get_cur_row_size(Tablet tablet); |
| |
| /** |
| * @brief Assigns timestamp to a row in the Tablet. |
| * |
| * @param tablet [in] Valid Tablet handle. |
| * @param row_index [in] Target row (0 ≤ index < max_rows). |
| * @param timestamp [in] Timestamp with int64_t type. |
| * @return ERRNO - RET_OK(0) or error code in errno_define_c.h. |
| */ |
| ERRNO tablet_add_timestamp(Tablet tablet, uint32_t row_index, |
| Timestamp timestamp); |
| |
| /** |
| * @brief Adds a string value to a Tablet row by column name. |
| * |
| * @param value [in] Null-terminated string. Ownership remains with caller. |
| * @return ERRNO. |
| */ |
| ERRNO tablet_add_value_by_name_string(Tablet tablet, uint32_t row_index, |
| const char* column_name, |
| const char* value); |
| |
| // Supports multiple data types |
| ERRNO tablet_add_value_by_name_int32_t(Tablet tablet, uint32_t row_index, |
| const char* column_name, |
| int32_t value); |
| ERRNO tablet_add_value_by_name_int64_t(Tablet tablet, uint32_t row_index, |
| const char* column_name, |
| int64_t value); |
| |
| ERRNO tablet_add_value_by_name_double(Tablet tablet, uint32_t row_index, |
| const char* column_name, |
| double value); |
| |
| ERRNO tablet_add_value_by_name_float(Tablet tablet, uint32_t row_index, |
| const char* column_name, |
| float value); |
| |
| ERRNO tablet_add_value_by_name_bool(Tablet tablet, uint32_t row_index, |
| const char* column_name, |
| bool value); |
| |
| |
| /** |
| * @brief Adds a string value to a Tablet row by column index. |
| * |
| * @param value [in] Null-terminated string. Copied internally. |
| */ |
| ERRNO tablet_add_value_by_index_string(Tablet tablet, uint32_t row_index, |
| uint32_t column_index, |
| const char* value); |
| |
| |
| // Supports multiple data types |
| ERRNO tablet_add_value_by_index_int32_t(Tablet tablet, uint32_t row_index, |
| uint32_t column_index, |
| int32_t value); |
| ERRNO tablet_add_value_by_index_int64_t(Tablet tablet, uint32_t row_index, |
| uint32_t column_index, |
| int64_t value); |
| |
| ERRNO tablet_add_value_by_index_double(Tablet tablet, uint32_t row_index, |
| uint32_t column_index, |
| double value); |
| |
| ERRNO tablet_add_value_by_index_float(Tablet tablet, uint32_t row_index, |
| uint32_t column_index, |
| float value); |
| |
| ERRNO tablet_add_value_by_index_bool(Tablet tablet, uint32_t row_index, |
| uint32_t column_index, |
| bool value); |
| |
| |
| void free_tablet(Tablet* tablet); |
| ``` |
| |
| |
| |
| ### Write Tablet into TsFile |
| |
| ```C |
| /** |
| * @brief Writes data from a Tablet to the TsFile. |
| * |
| * @param writer [in] Valid TsFileWriter handle. |
| * @param tablet [in] Tablet containing data. Should be freed after successful |
| * writing. |
| * @return ERRNO - RET_OK(0), or error code in errno_define_c.h. |
| * |
| */ |
| |
| ERRNO tsfile_writer_write(TsFileWriter writer, Tablet tablet); |
| ``` |
| |
| |
| |
| |
| |
| ## Configuration (encoding & compression) |
| |
| Columns are stored with the **global default** encoding and compression for their |
| data type (a `ColumnSchema` does not carry codec settings). Change those |
| defaults *before* creating a writer with the functions below. |
| |
| Each setter returns `RET_OK` (0) on success, or `RET_NOT_SUPPORT` (40) for an |
| unsupported data-type/encoding or compression combination. |
| |
| ```C |
| /* Default value encoding per data type, and default compression. */ |
| int set_datatype_encoding(uint8_t data_type, uint8_t encoding); |
| int set_global_compression(uint8_t compression); |
| uint8_t get_datatype_encoding(uint8_t data_type); |
| uint8_t get_global_compression(); |
| |
| /* Time column (the time data type is fixed to INT64). */ |
| int set_global_time_encoding(uint8_t encoding); |
| int set_global_time_compression(uint8_t compression); |
| uint8_t get_global_time_encoding(); |
| uint8_t get_global_time_compression(); |
| ``` |
| |
| Allowed encodings per data type, and the default used when you do not change it: |
| |
| | Data type | Allowed encodings | Default | |
| |---|---|---| |
| | `BOOLEAN` | `PLAIN` | `PLAIN` | |
| | `INT32`, `INT64`, `DATE` | `PLAIN`, `TS_2DIFF`, `GORILLA`, `ZIGZAG`, `RLE`, `SPRINTZ` | `TS_2DIFF` | |
| | `FLOAT`, `DOUBLE` | `PLAIN`, `TS_2DIFF`, `GORILLA`, `SPRINTZ` | `GORILLA` | |
| | `STRING`, `TEXT` | `PLAIN`, `DICTIONARY` | `PLAIN` | |
| |
| Compression applies to any data type: `UNCOMPRESSED`, `SNAPPY`, `GZIP`, `LZO`, or `LZ4` (default `LZ4`). |
| |
| ```C |
| // e.g. write every column with LZ4 compression |
| ERRNO code = set_global_compression(TS_COMPRESSION_LZ4); |
| if (code != RET_OK) { /* handle unsupported value */ } |
| ``` |
| |
| ## Read Interface |
| |
| ### TsFile Reader Create/Close |
| |
| ```C |
| /** |
| * @brief Creates a TsFileReader for reading a TsFile. |
| * |
| * @param pathname Source TsFiles path. Must be a valid path. |
| * @param err_code RET_OK(0), or error code in errno_define_c.h. |
| * @return TsFileReader Valid handle on success, NULL on failure. |
| * |
| * @note Call tsfile_reader_close() to release resources. |
| */ |
| |
| TsFileReader tsfile_reader_new(const char* pathname, ERRNO* err_code); |
| |
| /** |
| * @brief Releases resources associated with a TsFileReader. |
| * |
| * @param reader [in] Reader handle obtained from tsfile_reader_new(). |
| * After call: |
| * Handle becomes invalid and must not be reused. |
| * Result_set obtained by this handle becomes invalid. |
| * @return ERRNO - RET_OK(0) on success, or error code in errno_define_c.h. |
| */ |
| ERRNO tsfile_reader_close(TsFileReader reader); |
| ``` |
| |
| |
| |
| ### Query table/get next |
| |
| ```C |
| |
| /** |
| * @brief Query data from the specific table and columns within time range. |
| * |
| * @param reader [in] Valid TsFileReader handle from tsfile_reader_new(). |
| * @param table_name [in] Target table name. Must exist in the TsFile. |
| * @param columns [in] Array of column names to fetch. |
| * @param column_num [in] Number of columns in array. |
| * @param start_time [in] Start timestamp. |
| * @param end_time [in] End timestamp. Must ≥ start_time. |
| * @param err_code [out] RET_OK(0) on success, or error code in errno_define_c.h. |
| * @return ResultSet Query results handle. Must be freed with |
| * free_tsfile_result_set(). |
| */ |
| ResultSet tsfile_query_table(TsFileReader reader, const char* table_name, |
| char** columns, uint32_t column_num, |
| Timestamp start_time, Timestamp end_time, |
| ERRNO* err_code); |
| |
| /** |
| * @brief Check and fetch the next row in the ResultSet. |
| * |
| * @param result_set [in] Valid ResultSet handle. |
| * @param error_code RET_OK(0) on success, or error code in errno_define_c.h. |
| * @return bool - true: Row available, false: End of data or error. |
| */ |
| bool tsfile_result_set_next(ResultSet result_set, ERRNO* error_code); |
| |
| /** |
| * @brief Free Result set |
| * |
| * @param result_set [in] Valid ResultSet handle ptr. |
| */ |
| void free_tsfile_result_set(ResultSet* result_set); |
| ``` |
| |
| |
| |
| ### Filtering by tag |
| |
| **TAG columns** form the device identity (a joint primary |
| key) — their values are what distinguish one device from another within a table. |
| A *tag filter* restricts a query to the devices whose TAG values match a |
| predicate, so you read only the devices you care about. Build a filter from the |
| reader, pass it to one of the table-query functions below, then release it with |
| `tsfile_tag_filter_free()`. |
| |
| ```C |
| // Opaque handle to a tag filter. Build it with the functions below. |
| typedef void* TagFilterHandle; |
| |
| // Comparison operators for a single-column TAG predicate. |
| typedef enum { |
| TAG_FILTER_EQ = 0, // column == value |
| TAG_FILTER_NEQ = 1, // column != value |
| TAG_FILTER_LT = 2, // column < value |
| TAG_FILTER_LTEQ = 3, // column <= value |
| TAG_FILTER_GT = 4, // column > value |
| TAG_FILTER_GTEQ = 5, // column >= value |
| TAG_FILTER_REGEXP = 6, // column matches the regex value |
| TAG_FILTER_NOT_REGEXP = 7, // column does not match the regex value |
| } TagFilterOp; |
| |
| /** |
| * @brief Create a single-column TAG predicate: `<column_name> <op> <value>`. |
| * |
| * @param reader [in] Valid TsFileReader handle. |
| * @param table_name [in] Table whose schema defines the TAG columns. |
| * @param column_name [in] Name of the TAG column to filter on. |
| * @param value [in] Comparison value (TAG columns are STRING). |
| * @param op [in] Comparison operator (TagFilterOp). |
| * @param err_code [out] RET_OK(0) on success, or error code in errno_define_c.h. |
| * @return TagFilterHandle on success; NULL on failure. |
| */ |
| TagFilterHandle tsfile_tag_filter_create(TsFileReader reader, |
| const char* table_name, |
| const char* column_name, |
| const char* value, TagFilterOp op, |
| ERRNO* err_code); |
| |
| /** |
| * @brief Create a range predicate: lower <= column <= upper |
| * (pass is_not = true for NOT BETWEEN). |
| */ |
| TagFilterHandle tsfile_tag_filter_between(TsFileReader reader, |
| const char* table_name, |
| const char* column_name, |
| const char* lower, const char* upper, |
| bool is_not, ERRNO* err_code); |
| |
| // Combine predicates. AND/OR/NOT take ownership of their children; free the root only. |
| TagFilterHandle tsfile_tag_filter_and(TagFilterHandle left, TagFilterHandle right); |
| TagFilterHandle tsfile_tag_filter_or(TagFilterHandle left, TagFilterHandle right); |
| TagFilterHandle tsfile_tag_filter_not(TagFilterHandle filter); |
| |
| // Free a tag filter and all of its children. |
| void tsfile_tag_filter_free(TagFilterHandle filter); |
| ``` |
| |
| ### Table queries with tag filter, paging and batching |
| |
| These query functions accept an optional `tag_filter` (pass `NULL` |
| for no filtering) and a `batch_size` (`<= 0` returns rows one by one; `> 0` |
| returns a block of that size). |
| |
| ```C |
| /** |
| * @brief Query a table by row, with offset/limit pushdown and an optional tag filter. |
| * |
| * @param reader [in] Valid TsFileReader handle. |
| * @param table_name [in] Target table name. |
| * @param column_names [in] Requested column names. |
| * @param column_names_len [in] Number of requested columns. |
| * @param offset [in] Leading rows to skip (>= 0). |
| * @param limit [in] Max rows to return; < 0 means unlimited. |
| * @param tag_filter [in] TAG predicate, or NULL for no filtering. |
| * @param batch_size [in] <= 0 row-by-row; > 0 block size. |
| * @param err_code [out] RET_OK(0) on success, or error code. |
| * @return ResultSet handle; NULL on failure. Free with free_tsfile_result_set(). |
| */ |
| ResultSet tsfile_reader_query_table_by_row( |
| TsFileReader reader, const char* table_name, char** column_names, |
| int column_names_len, int offset, int limit, TagFilterHandle tag_filter, |
| int batch_size, ERRNO* err_code); |
| |
| /** |
| * @brief Query a table within a time range, with an optional tag filter and batching. |
| * |
| * @param batch_size <= 0 row-by-row return; > 0 returns a TsBlock of that size. |
| */ |
| ResultSet tsfile_query_table_batch(TsFileReader reader, const char* table_name, |
| char** columns, uint32_t column_num, |
| Timestamp start_time, Timestamp end_time, |
| TagFilterHandle tag_filter, int batch_size, |
| ERRNO* err_code); |
| |
| /** |
| * @brief Query a table with a tag filter (time range + TAG predicate). |
| * |
| * @param batch_size <= 0 row-by-row return; > 0 returns a TsBlock of that size. |
| */ |
| ResultSet tsfile_query_table_with_tag_filter( |
| TsFileReader reader, const char* table_name, char** columns, |
| uint32_t column_num, Timestamp start_time, Timestamp end_time, |
| TagFilterHandle tag_filter, int batch_size, ERRNO* err_code); |
| ``` |
| |
| Example — read `temperature` only for devices whose `region` TAG equals |
| `shanghai`: |
| |
| ```C |
| ERRNO ec = RET_OK; |
| TagFilterHandle f = tsfile_tag_filter_create( |
| reader, "weather", "region", "shanghai", TAG_FILTER_EQ, &ec); |
| |
| char* cols[] = {"temperature"}; |
| ResultSet rs = tsfile_reader_query_table_by_row( |
| reader, "weather", cols, 1, /*offset*/ 0, /*limit*/ -1, f, /*batch*/ 0, &ec); |
| |
| // ... iterate rs with tsfile_result_set_next(), then release: |
| free_tsfile_result_set(&rs); |
| tsfile_tag_filter_free(f); |
| ``` |
| |
| ### Get Data from result set |
| |
| ```c |
| /** |
| * @brief Checks if the current row's column value is NULL by column name. |
| * |
| * @param result_set [in] Valid ResultSet with active row (after next()=true). |
| * @param column_name [in] Existing column name in result schema. |
| * @return bool - true: Value is NULL or column not found, false: Valid value. |
| */ |
| bool tsfile_result_set_is_null_by_name(ResultSet result_set, |
| const char* column_name); |
| |
| /** |
| * @brief Checks if the current row's column value is NULL by column index. |
| * |
| * @param column_index [in] Column position (1 <= index <= result_column_count). |
| * @return bool - true: Value is NULL or index out of range, false: Valid value. |
| */ |
| bool tsfile_result_set_is_null_by_index(ResultSet result_set, |
| uint32_t column_index); |
| |
| /** |
| * @brief Gets string value from current row by column name. |
| * @param result_set [in] valid result set handle. |
| * @param column_name [in] the name of the column to be checked. |
| * @return char* - String pointer. Caller must free this ptr after usage. |
| */ |
| char* tsfile_result_set_get_value_by_name_string(ResultSet result_set, |
| const char* column_name); |
| |
| // Supports multiple data types |
| bool tsfile_result_set_get_value_by_name_bool(ResultSet result_set, const char* |
| column_name); |
| int32_t tsfile_result_set_get_value_by_name_int32_t(ResultSet result_set, const char* |
| column_name); |
| int64_t tsfile_result_set_get_value_by_name_int64_t(ResultSet result_set, const char* |
| column_name); |
| float tsfile_result_set_get_value_by_name_float(ResultSet result_set, const char* |
| column_name); |
| double tsfile_result_set_get_value_by_name_double(ResultSet result_set, const char* |
| column_name); |
| |
| /** |
| * @brief Gets string value from current row by column index. |
| * @param result_set [in] valid result set handle. |
| * @param column_index [in] the index of the column to be checked (1 <= index <= column_num). |
| * @return char* - String pointer. Caller must free this ptr after usage. |
| */ |
| char* tsfile_result_set_get_value_by_index_string(ResultSet result_set, |
| uint32_t column_index); |
| |
| // Supports multiple data types |
| int32_t tsfile_result_set_get_value_by_index_int32_t(ResultSet result_set, uint32_t |
| column_index); |
| int64_t tsfile_result_set_get_value_by_index_int64_t(ResultSet result_set, uint32_t |
| column_index); |
| float tsfile_result_set_get_value_by_index_float(ResultSet result_set, uint32_t |
| column_index); |
| double tsfile_result_set_get_value_by_index_double(ResultSet result_set, uint32_t |
| column_index); |
| bool tsfile_result_set_get_value_by_index_bool(ResultSet result_set, uint32_t |
| column_index); |
| |
| /** |
| * @brief Retrieves metadata describing the ResultSet's schema. |
| * |
| * @param result_set [in] Valid result set handle. |
| * @return ResultSetMetaData Metadata handle. Caller should free the |
| * ResultSetMataData after usage. |
| * @note Before calling this func, check if the result_set is NULL, which |
| * may indicates a failed query execution. |
| */ |
| ResultSetMetaData tsfile_result_set_get_metadata(ResultSet result_set); |
| |
| /** |
| * @brief Gets column name by index from metadata. |
| * @param result_set_meta_data [in] Valid result set handle. |
| * @param column_index [in] Column position (1 <= index <= column_num). |
| * @return const char* Read-only string. NULL if index invalid. |
| */ |
| char* tsfile_result_set_metadata_get_column_name(ResultSetMetaData result_set_meta_data, |
| uint32_t column_index); |
| |
| /** |
| * @brief Gets column data type by index from metadata. |
| * @param result_set_meta_data [in] Valid result set meta data handle. |
| * @param column_index [in] Column position (1 <= index <= column_num). |
| * @return TSDataType Returns TS_DATATYPE_INVALID(255) if index invalid. |
| */ |
| TSDataType tsfile_result_set_metadata_get_data_type( |
| ResultSetMetaData result_set_meta_data, uint32_t column_index); |
| |
| /** |
| * @brief Gets total number of columns in the result schema. |
| * @param result_set_meta_data [in] Valid result set meta data handle. |
| * @return column num in result set metadata. |
| */ |
| int tsfile_result_set_metadata_get_column_num(ResultSetMetaData result_set); |
| ``` |
| |
| |
| |
| ### Get Table Schema from TsFile Reader |
| |
| ```C |
| /** |
| * @brief Gets specific table's schema in the tsfile. |
| * @param reader [in], valid reader handle. |
| * @param table_name [in] Target table name. Must exist in the TsFile. |
| * @return TableSchema, contains table and column info. |
| * @note Caller should call free_table_schema to free the tableschema. |
| */ |
| TableSchema tsfile_reader_get_table_schema(TsFileReader reader, |
| const char* table_name); |
| /** |
| * @brief Gets all tables' schema in the tsfile. |
| * @param size[out] num of tableschema in return ptr. |
| * @return TableSchema*, an array of table schema. |
| * @note The caller must call free_table_schema() on each array element |
| * and free to deallocate the array pointer. |
| */ |
| TableSchema* tsfile_reader_get_all_table_schemas(TsFileReader reader, |
| uint32_t* size); |
| |
| /** |
| * @brief Free the tableschema's space. |
| * @param schema [in] the table schema to be freed. |
| */ |
| void free_table_schema(TableSchema schema); |
| ``` |
| |
| |
| |
| |
| |
| |
| |
| |
