iotdb-client/client-cpp/src/session/SessionC.cpp

/**
 * 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.
 */

#include "SessionC.h"
#include "Session.h"
#include "SessionBuilder.h"
#include "SessionDataSet.h"

#include <cstring>
#include <map>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>

/* ============================================================
 *  Internal wrapper structs — the opaque handles point to these
 * ============================================================ */

struct CSession_ {
  std::shared_ptr<Session> cpp;
};

struct CTablet_ {
  Tablet cpp;
};

struct CSessionDataSet_ {
  std::unique_ptr<SessionDataSet> cpp;
};

struct CRowRecord_ {
  std::shared_ptr<RowRecord> cpp;
};

/* ============================================================
 *  Thread-local error message buffer
 * ============================================================ */

static thread_local std::string g_lastError;

static void clearError() { g_lastError.clear(); }

static TsStatus setError(TsStatus code, const std::string &msg) {
  g_lastError = msg;
  return code;
}

static TsStatus setError(TsStatus code, const std::exception &e) {
  g_lastError = e.what();
  return code;
}

static TsStatus handleException(const std::exception &e) {
#if defined(_CPPRTTI) || defined(__GXX_RTTI)
  // Try to classify exception type (requires RTTI enabled).
  if (dynamic_cast<const IoTDBConnectionException *>(&e)) {
    return setError(TS_ERR_CONNECTION, e);
  }
  if (dynamic_cast<const ExecutionException *>(&e) ||
      dynamic_cast<const StatementExecutionException *>(&e) ||
      dynamic_cast<const BatchExecutionException *>(&e)) {
    return setError(TS_ERR_EXECUTION, e);
  }
#endif
  return setError(TS_ERR_UNKNOWN, e);
}

extern "C" {

const char *ts_get_last_error(void) { return g_lastError.c_str(); }

} /* extern "C" */

/* ============================================================
 *  Helpers — convert C arrays to C++ vectors
 * ============================================================ */

static std::vector<std::string> toStringVec(const char *const *arr, int count) {
  std::vector<std::string> v;
  v.reserve(count);
  for (int i = 0; i < count; i++) {
    v.emplace_back(arr[i]);
  }
  return v;
}

static std::vector<TSDataType::TSDataType> toTypeVec(const TSDataType_C *arr,
                                                     int count) {
  std::vector<TSDataType::TSDataType> v;
  v.reserve(count);
  for (int i = 0; i < count; i++) {
    v.push_back(static_cast<TSDataType::TSDataType>(arr[i]));
  }
  return v;
}

static std::vector<TSEncoding::TSEncoding>
toEncodingVec(const TSEncoding_C *arr, int count) {
  std::vector<TSEncoding::TSEncoding> v;
  v.reserve(count);
  for (int i = 0; i < count; i++) {
    v.push_back(static_cast<TSEncoding::TSEncoding>(arr[i]));
  }
  return v;
}

static std::vector<CompressionType::CompressionType>
toCompressionVec(const TSCompressionType_C *arr, int count) {
  std::vector<CompressionType::CompressionType> v;
  v.reserve(count);
  for (int i = 0; i < count; i++) {
    v.push_back(static_cast<CompressionType::CompressionType>(arr[i]));
  }
  return v;
}

static std::map<std::string, std::string>
toStringMap(int count, const char *const *keys, const char *const *values) {
  std::map<std::string, std::string> m;
  for (int i = 0; i < count; i++) {
    m[keys[i]] = values[i];
  }
  return m;
}

/**
 * Convert C typed values (void* const* values, TSDataType_C* types, int count)
 * to C++ vector<char*> that Session expects.
 * The caller must free the returned char* pointers using freeCharPtrVec().
 */
static std::vector<char *> toCharPtrVec(const TSDataType_C *types,
                                        const void *const *values, int count) {
  std::vector<char *> result(count);
  for (int i = 0; i < count; i++) {
    switch (types[i]) {
    case TS_TYPE_BOOLEAN: {
      bool *p = new bool(*static_cast<const bool *>(values[i]));
      result[i] = reinterpret_cast<char *>(p);
      break;
    }
    case TS_TYPE_INT32: {
      int32_t *p = new int32_t(*static_cast<const int32_t *>(values[i]));
      result[i] = reinterpret_cast<char *>(p);
      break;
    }
    case TS_TYPE_INT64:
    case TS_TYPE_TIMESTAMP: {
      int64_t *p = new int64_t(*static_cast<const int64_t *>(values[i]));
      result[i] = reinterpret_cast<char *>(p);
      break;
    }
    case TS_TYPE_FLOAT: {
      float *p = new float(*static_cast<const float *>(values[i]));
      result[i] = reinterpret_cast<char *>(p);
      break;
    }
    case TS_TYPE_DOUBLE: {
      double *p = new double(*static_cast<const double *>(values[i]));
      result[i] = reinterpret_cast<char *>(p);
      break;
    }
    case TS_TYPE_TEXT:
    case TS_TYPE_STRING:
    case TS_TYPE_BLOB:
    default: {
      const char *src = static_cast<const char *>(values[i]);
      size_t len = strlen(src) + 1;
      char *p = new char[len];
      memcpy(p, src, len);
      result[i] = p;
      break;
    }
    }
  }
  return result;
}

static void freeCharPtrVec(std::vector<char *> &vec, const TSDataType_C *types,
                           int count) {
  for (int i = 0; i < count; i++) {
    switch (types[i]) {
    case TS_TYPE_BOOLEAN:
      delete reinterpret_cast<bool *>(vec[i]);
      break;
    case TS_TYPE_INT32:
      delete reinterpret_cast<int32_t *>(vec[i]);
      break;
    case TS_TYPE_INT64:
    case TS_TYPE_TIMESTAMP:
      delete reinterpret_cast<int64_t *>(vec[i]);
      break;
    case TS_TYPE_FLOAT:
      delete reinterpret_cast<float *>(vec[i]);
      break;
    case TS_TYPE_DOUBLE:
      delete reinterpret_cast<double *>(vec[i]);
      break;
    default:
      delete[] vec[i];
      break;
    }
  }
}

/* ============================================================
 *  Session Lifecycle  —  Tree Model
 * ============================================================ */

extern "C" {

CSession *ts_session_new(const char *host, int rpcPort, const char *username,
                         const char *password) {
  clearError();
  try {
    SessionBuilder builder;
    builder.host(host)
        ->rpcPort(rpcPort)
        ->username(username)
        ->password(password)
        ->enableAutoFetch(false);
    auto cpp = std::make_shared<Session>(&builder);
    auto *cs = new CSession_();
    cs->cpp = std::move(cpp);
    return cs;
  } catch (const std::exception &e) {
    handleException(e);
    return nullptr;
  }
}

CSession *ts_session_new_with_zone(const char *host, int rpcPort,
                                   const char *username, const char *password,
                                   const char *zoneId, int fetchSize) {
  clearError();
  try {
    SessionBuilder builder;
    builder.host(host)
        ->rpcPort(rpcPort)
        ->username(username)
        ->password(password)
        ->zoneId(zoneId)
        ->fetchSize(fetchSize)
        ->enableAutoFetch(false);
    auto cpp = std::make_shared<Session>(&builder);
    auto *cs = new CSession_();
    cs->cpp = std::move(cpp);
    return cs;
  } catch (const std::exception &e) {
    handleException(e);
    return nullptr;
  }
}

CSession *ts_session_new_multi_node(const char *const *nodeUrls, int urlCount,
                                    const char *username,
                                    const char *password) {
  clearError();
  try {
    auto urls = toStringVec(nodeUrls, urlCount);
    SessionBuilder builder;
    builder.nodeUrls(urls)
        ->username(username)
        ->password(password)
        ->enableAutoFetch(false);
    auto cpp = std::make_shared<Session>(&builder);
    auto *cs = new CSession_();
    cs->cpp = std::move(cpp);
    return cs;
  } catch (const std::exception &e) {
    handleException(e);
    return nullptr;
  }
}

void ts_session_destroy(CSession *session) { delete session; }

TsStatus ts_session_open(CSession *session) {
  clearError();
  if (!session)
    return setError(TS_ERR_NULL_PTR, "session is null");
  try {
    session->cpp->open();
    return TS_OK;
  } catch (const std::exception &e) {
    return handleException(e);
  }
}

TsStatus ts_session_open_with_compression(CSession *session,
                                          bool enableRPCCompression) {
  clearError();
  if (!session)
    return setError(TS_ERR_NULL_PTR, "session is null");
  try {
    session->cpp->open(enableRPCCompression);
    return TS_OK;
  } catch (const std::exception &e) {
    return handleException(e);
  }
}

TsStatus ts_session_close(CSession *session) {
  clearError();
  if (!session)
    return setError(TS_ERR_NULL_PTR, "session is null");
  try {
    session->cpp->close();
    return TS_OK;
  } catch (const std::exception &e) {
    return handleException(e);
  }
}

/* ============================================================
 *  Timezone
 * ============================================================ */

TsStatus ts_session_set_timezone(CSession *session, const char *zoneId) {
  clearError();
  if (!session)
    return setError(TS_ERR_NULL_PTR, "session is null");
  try {
    session->cpp->setTimeZone(std::string(zoneId));
    return TS_OK;
  } catch (const std::exception &e) {
    return handleException(e);
  }
}

TsStatus ts_session_get_timezone(CSession *session, char *buf, int bufLen) {
  clearError();
  if (!session)
    return setError(TS_ERR_NULL_PTR, "session is null");
  if (!buf || bufLen <= 0)
    return setError(TS_ERR_INVALID_PARAM, "invalid buffer");
  try {
    std::string tz = session->cpp->getTimeZone();
    if ((int)tz.size() >= bufLen) {
      return setError(TS_ERR_INVALID_PARAM, "buffer too small");
    }
    strncpy(buf, tz.c_str(), bufLen);
    buf[bufLen - 1] = '\0';
    return TS_OK;
  } catch (const std::exception &e) {
    return handleException(e);
  }
}

/* ============================================================
 *  Database Management  (Tree Model)
 * ============================================================ */

TsStatus ts_session_create_database(CSession *session, const char *database) {
  clearError();
  if (!session)
    return setError(TS_ERR_NULL_PTR, "session is null");
  try {
    session->cpp->createDatabase(std::string(database));
    return TS_OK;
  } catch (const std::exception &e) {
    return handleException(e);
  }
}

TsStatus ts_session_delete_database(CSession *session, const char *database) {
  clearError();
  if (!session)
    return setError(TS_ERR_NULL_PTR, "session is null");
  try {
    session->cpp->deleteDatabase(std::string(database));
    return TS_OK;
  } catch (const std::exception &e) {
    return handleException(e);
  }
}

TsStatus ts_session_delete_databases(CSession *session,
                                     const char *const *databases, int count) {
  clearError();
  if (!session)
    return setError(TS_ERR_NULL_PTR, "session is null");
  try {
    auto dbs = toStringVec(databases, count);
    session->cpp->deleteDatabases(dbs);
    return TS_OK;
  } catch (const std::exception &e) {
    return handleException(e);
  }
}

/* ============================================================
 *  Timeseries Management  (Tree Model)
 * ============================================================ */

TsStatus ts_session_create_timeseries(CSession *session, const char *path,
                                      TSDataType_C dataType,
                                      TSEncoding_C encoding,
                                      TSCompressionType_C compressor) {
  clearError();
  if (!session)
    return setError(TS_ERR_NULL_PTR, "session is null");
  try {
    session->cpp->createTimeseries(
        std::string(path), static_cast<TSDataType::TSDataType>(dataType),
        static_cast<TSEncoding::TSEncoding>(encoding),
        static_cast<CompressionType::CompressionType>(compressor));
    return TS_OK;
  } catch (const std::exception &e) {
    return handleException(e);
  }
}

TsStatus ts_session_create_timeseries_ex(
    CSession *session, const char *path, TSDataType_C dataType,
    TSEncoding_C encoding, TSCompressionType_C compressor, int propsCount,
    const char *const *propKeys, const char *const *propValues, int tagsCount,
    const char *const *tagKeys, const char *const *tagValues, int attrsCount,
    const char *const *attrKeys, const char *const *attrValues,
    const char *measurementAlias) {
  clearError();
  if (!session)
    return setError(TS_ERR_NULL_PTR, "session is null");
  try {
    std::map<std::string, std::string> props =
        propsCount > 0 ? toStringMap(propsCount, propKeys, propValues)
                       : std::map<std::string, std::string>();
    std::map<std::string, std::string> tags =
        tagsCount > 0 ? toStringMap(tagsCount, tagKeys, tagValues)
                      : std::map<std::string, std::string>();
    std::map<std::string, std::string> attrs =
        attrsCount > 0 ? toStringMap(attrsCount, attrKeys, attrValues)
                       : std::map<std::string, std::string>();
    session->cpp->createTimeseries(
        std::string(path), static_cast<TSDataType::TSDataType>(dataType),
        static_cast<TSEncoding::TSEncoding>(encoding),
        static_cast<CompressionType::CompressionType>(compressor), &props,
        &tags, &attrs, std::string(measurementAlias ? measurementAlias : ""));
    return TS_OK;
  } catch (const std::exception &e) {
    return handleException(e);
  }
}

TsStatus ts_session_create_multi_timeseries(
    CSession *session, int count, const char *const *paths,
    const TSDataType_C *dataTypes, const TSEncoding_C *encodings,
    const TSCompressionType_C *compressors) {
  clearError();
  if (!session)
    return setError(TS_ERR_NULL_PTR, "session is null");
  try {
    auto pathsVec = toStringVec(paths, count);
    auto typesVec = toTypeVec(dataTypes, count);
    auto encVec = toEncodingVec(encodings, count);
    auto compVec = toCompressionVec(compressors, count);
    session->cpp->createMultiTimeseries(pathsVec, typesVec, encVec, compVec,
                                        nullptr, nullptr, nullptr, nullptr);
    return TS_OK;
  } catch (const std::exception &e) {
    return handleException(e);
  }
}

TsStatus ts_session_create_aligned_timeseries(
    CSession *session, const char *deviceId, int count,
    const char *const *measurements, const TSDataType_C *dataTypes,
    const TSEncoding_C *encodings, const TSCompressionType_C *compressors) {
  clearError();
  if (!session)
    return setError(TS_ERR_NULL_PTR, "session is null");
  try {
    auto measurementsVec = toStringVec(measurements, count);
    auto typesVec = toTypeVec(dataTypes, count);
    auto encVec = toEncodingVec(encodings, count);
    auto compVec = toCompressionVec(compressors, count);
    session->cpp->createAlignedTimeseries(
        std::string(deviceId), measurementsVec, typesVec, encVec, compVec);
    return TS_OK;
  } catch (const std::exception &e) {
    return handleException(e);
  }
}

TsStatus ts_session_check_timeseries_exists(CSession *session, const char *path,
                                            bool *exists) {
  clearError();
  if (!session)
    return setError(TS_ERR_NULL_PTR, "session is null");
  if (!exists)
    return setError(TS_ERR_INVALID_PARAM, "exists pointer is null");
  try {
    *exists = session->cpp->checkTimeseriesExists(std::string(path));
    return TS_OK;
  } catch (const std::exception &e) {
    return handleException(e);
  }
}

TsStatus ts_session_delete_timeseries(CSession *session, const char *path) {
  clearError();
  if (!session)
    return setError(TS_ERR_NULL_PTR, "session is null");
  try {
    session->cpp->deleteTimeseries(std::string(path));
    return TS_OK;
  } catch (const std::exception &e) {
    return handleException(e);
  }
}

TsStatus ts_session_delete_timeseries_batch(CSession *session,
                                            const char *const *paths,
                                            int count) {
  clearError();
  if (!session)
    return setError(TS_ERR_NULL_PTR, "session is null");
  try {
    auto pathsVec = toStringVec(paths, count);
    session->cpp->deleteTimeseries(pathsVec);
    return TS_OK;
  } catch (const std::exception &e) {
    return handleException(e);
  }
}

/* ============================================================
 *  Tablet Operations
 * ============================================================ */

CTablet *ts_tablet_new(const char *deviceId, int columnCount,
                       const char *const *columnNames,
                       const TSDataType_C *dataTypes, int maxRowNumber) {
  try {
    std::vector<std::pair<std::string, TSDataType::TSDataType>> schemas;
    schemas.reserve(columnCount);
    for (int i = 0; i < columnCount; i++) {
      schemas.emplace_back(std::string(columnNames[i]),
                           static_cast<TSDataType::TSDataType>(dataTypes[i]));
    }
    Tablet tablet(std::string(deviceId), schemas, maxRowNumber);
    auto *ct = new CTablet_();
    ct->cpp = std::move(tablet);
    return ct;
  } catch (const std::exception &e) {
    handleException(e);
    return nullptr;
  }
}

void ts_tablet_destroy(CTablet *tablet) { delete tablet; }

void ts_tablet_reset(CTablet *tablet) {
  if (tablet) {
    tablet->cpp.reset();
  }
}

int ts_tablet_get_row_count(CTablet *tablet) {
  if (!tablet)
    return 0;
  return static_cast<int>(tablet->cpp.rowSize);
}

TsStatus ts_tablet_set_row_count(CTablet *tablet, int rowCount) {
  clearError();
  if (!tablet)
    return setError(TS_ERR_NULL_PTR, "tablet is null");
  tablet->cpp.rowSize = rowCount;
  return TS_OK;
}

TsStatus ts_tablet_add_timestamp(CTablet *tablet, int rowIndex,
                                 int64_t timestamp) {
  clearError();
  if (!tablet)
    return setError(TS_ERR_NULL_PTR, "tablet is null");
  try {
    tablet->cpp.addTimestamp(static_cast<size_t>(rowIndex), timestamp);
    return TS_OK;
  } catch (const std::exception &e) {
    return handleException(e);
  }
}

TsStatus ts_tablet_add_value_bool(CTablet *tablet, int colIndex, int rowIndex,
                                  bool value) {
  clearError();
  if (!tablet)
    return setError(TS_ERR_NULL_PTR, "tablet is null");
  try {
    tablet->cpp.addValue(static_cast<size_t>(colIndex),
                         static_cast<size_t>(rowIndex), value);
    return TS_OK;
  } catch (const std::exception &e) {
    return handleException(e);
  }
}

TsStatus ts_tablet_add_value_int32(CTablet *tablet, int colIndex, int rowIndex,
                                   int32_t value) {
  clearError();
  if (!tablet)
    return setError(TS_ERR_NULL_PTR, "tablet is null");
  try {
    tablet->cpp.addValue(static_cast<size_t>(colIndex),
                         static_cast<size_t>(rowIndex), value);
    return TS_OK;
  } catch (const std::exception &e) {
    return handleException(e);
  }
}

TsStatus ts_tablet_add_value_int64(CTablet *tablet, int colIndex, int rowIndex,
                                   int64_t value) {
  clearError();
  if (!tablet)
    return setError(TS_ERR_NULL_PTR, "tablet is null");
  try {
    tablet->cpp.addValue(static_cast<size_t>(colIndex),
                         static_cast<size_t>(rowIndex), value);
    return TS_OK;
  } catch (const std::exception &e) {
    return handleException(e);
  }
}

TsStatus ts_tablet_add_value_float(CTablet *tablet, int colIndex, int rowIndex,
                                   float value) {
  clearError();
  if (!tablet)
    return setError(TS_ERR_NULL_PTR, "tablet is null");
  try {
    tablet->cpp.addValue(static_cast<size_t>(colIndex),
                         static_cast<size_t>(rowIndex), value);
    return TS_OK;
  } catch (const std::exception &e) {
    return handleException(e);
  }
}

TsStatus ts_tablet_add_value_double(CTablet *tablet, int colIndex, int rowIndex,
                                    double value) {
  clearError();
  if (!tablet)
    return setError(TS_ERR_NULL_PTR, "tablet is null");
  try {
    tablet->cpp.addValue(static_cast<size_t>(colIndex),
                         static_cast<size_t>(rowIndex), value);
    return TS_OK;
  } catch (const std::exception &e) {
    return handleException(e);
  }
}

TsStatus ts_tablet_add_value_string(CTablet *tablet, int colIndex, int rowIndex,
                                    const char *value) {
  clearError();
  if (!tablet)
    return setError(TS_ERR_NULL_PTR, "tablet is null");
  try {
    std::string str(value);
    tablet->cpp.addValue(static_cast<size_t>(colIndex),
                         static_cast<size_t>(rowIndex), str);
    return TS_OK;
  } catch (const std::exception &e) {
    return handleException(e);
  }
}

/* ============================================================
 *  Data Insertion  —  Tree Model  (Record, string values)
 * ============================================================ */

TsStatus ts_session_insert_record_str(CSession *session, const char *deviceId,
                                      int64_t time, int count,
                                      const char *const *measurements,
                                      const char *const *values) {
  clearError();
  if (!session)
    return setError(TS_ERR_NULL_PTR, "session is null");
  try {
    auto measurementsVec = toStringVec(measurements, count);
    auto valuesVec = toStringVec(values, count);
    session->cpp->insertRecord(std::string(deviceId), time, measurementsVec,
                               valuesVec);
    return TS_OK;
  } catch (const std::exception &e) {
    return handleException(e);
  }
}

TsStatus ts_session_insert_record(CSession *session, const char *deviceId,
                                  int64_t time, int count,
                                  const char *const *measurements,
                                  const TSDataType_C *types,
                                  const void *const *values) {
  clearError();
  if (!session)
    return setError(TS_ERR_NULL_PTR, "session is null");
  try {
    auto measurementsVec = toStringVec(measurements, count);
    auto typesVec = toTypeVec(types, count);
    auto charVec = toCharPtrVec(types, values, count);
    session->cpp->insertRecord(std::string(deviceId), time, measurementsVec,
                               typesVec, charVec);
    freeCharPtrVec(charVec, types, count);
    return TS_OK;
  } catch (const std::exception &e) {
    return handleException(e);
  }
}

TsStatus ts_session_insert_aligned_record_str(CSession *session,
                                              const char *deviceId,
                                              int64_t time, int count,
                                              const char *const *measurements,
                                              const char *const *values) {
  clearError();
  if (!session)
    return setError(TS_ERR_NULL_PTR, "session is null");
  try {
    auto measurementsVec = toStringVec(measurements, count);
    auto valuesVec = toStringVec(values, count);
    session->cpp->insertAlignedRecord(std::string(deviceId), time,
                                      measurementsVec, valuesVec);
    return TS_OK;
  } catch (const std::exception &e) {
    return handleException(e);
  }
}

TsStatus ts_session_insert_aligned_record(CSession *session,
                                          const char *deviceId, int64_t time,
                                          int count,
                                          const char *const *measurements,
                                          const TSDataType_C *types,
                                          const void *const *values) {
  clearError();
  if (!session)
    return setError(TS_ERR_NULL_PTR, "session is null");
  try {
    auto measurementsVec = toStringVec(measurements, count);
    auto typesVec = toTypeVec(types, count);
    auto charVec = toCharPtrVec(types, values, count);
    session->cpp->insertAlignedRecord(std::string(deviceId), time,
                                      measurementsVec, typesVec, charVec);
    freeCharPtrVec(charVec, types, count);
    return TS_OK;
  } catch (const std::exception &e) {
    return handleException(e);
  }
}

/* ============================================================
 *  Data Insertion  —  Batch, multiple devices (string values)
 * ============================================================ */

TsStatus ts_session_insert_records_str(
    CSession *session, int deviceCount, const char *const *deviceIds,
    const int64_t *times, const int *measurementCounts,
    const char *const *const *measurementsList,
    const char *const *const *valuesList) {
  clearError();
  if (!session)
    return setError(TS_ERR_NULL_PTR, "session is null");
  try {
    auto devVec = toStringVec(deviceIds, deviceCount);
    std::vector<int64_t> timesVec(times, times + deviceCount);
    std::vector<std::vector<std::string>> mList, vList;
    mList.reserve(deviceCount);
    vList.reserve(deviceCount);
    for (int i = 0; i < deviceCount; i++) {
      mList.push_back(toStringVec(measurementsList[i], measurementCounts[i]));
      vList.push_back(toStringVec(valuesList[i], measurementCounts[i]));
    }
    session->cpp->insertRecords(devVec, timesVec, mList, vList);
    return TS_OK;
  } catch (const std::exception &e) {
    return handleException(e);
  }
}

TsStatus ts_session_insert_aligned_records_str(
    CSession *session, int deviceCount, const char *const *deviceIds,
    const int64_t *times, const int *measurementCounts,
    const char *const *const *measurementsList,
    const char *const *const *valuesList) {
  clearError();
  if (!session)
    return setError(TS_ERR_NULL_PTR, "session is null");
  try {
    auto devVec = toStringVec(deviceIds, deviceCount);
    std::vector<int64_t> timesVec(times, times + deviceCount);
    std::vector<std::vector<std::string>> mList, vList;
    mList.reserve(deviceCount);
    vList.reserve(deviceCount);
    for (int i = 0; i < deviceCount; i++) {
      mList.push_back(toStringVec(measurementsList[i], measurementCounts[i]));
      vList.push_back(toStringVec(valuesList[i], measurementCounts[i]));
    }
    session->cpp->insertAlignedRecords(devVec, timesVec, mList, vList);
    return TS_OK;
  } catch (const std::exception &e) {
    return handleException(e);
  }
}

/* ============================================================
 *  Data Insertion  —  Batch, multiple devices (typed values)
 * ============================================================ */

TsStatus ts_session_insert_records(CSession *session, int deviceCount,
                                   const char *const *deviceIds,
                                   const int64_t *times,
                                   const int *measurementCounts,
                                   const char *const *const *measurementsList,
                                   const TSDataType_C *const *typesList,
                                   const void *const *const *valuesList) {
  clearError();
  if (!session)
    return setError(TS_ERR_NULL_PTR, "session is null");
  try {
    auto devVec = toStringVec(deviceIds, deviceCount);
    std::vector<int64_t> timesVec(times, times + deviceCount);
    std::vector<std::vector<std::string>> mList;
    std::vector<std::vector<TSDataType::TSDataType>> tList;
    std::vector<std::vector<char *>> vList;
    mList.reserve(deviceCount);
    tList.reserve(deviceCount);
    vList.reserve(deviceCount);
    for (int i = 0; i < deviceCount; i++) {
      mList.push_back(toStringVec(measurementsList[i], measurementCounts[i]));
      tList.push_back(toTypeVec(typesList[i], measurementCounts[i]));
      vList.push_back(
          toCharPtrVec(typesList[i], valuesList[i], measurementCounts[i]));
    }
    session->cpp->insertRecords(devVec, timesVec, mList, tList, vList);
    for (int i = 0; i < deviceCount; i++) {
      freeCharPtrVec(vList[i], typesList[i], measurementCounts[i]);
    }
    return TS_OK;
  } catch (const std::exception &e) {
    return handleException(e);
  }
}

TsStatus ts_session_insert_aligned_records(
    CSession *session, int deviceCount, const char *const *deviceIds,
    const int64_t *times, const int *measurementCounts,
    const char *const *const *measurementsList,
    const TSDataType_C *const *typesList,
    const void *const *const *valuesList) {
  clearError();
  if (!session)
    return setError(TS_ERR_NULL_PTR, "session is null");
  try {
    auto devVec = toStringVec(deviceIds, deviceCount);
    std::vector<int64_t> timesVec(times, times + deviceCount);
    std::vector<std::vector<std::string>> mList;
    std::vector<std::vector<TSDataType::TSDataType>> tList;
    std::vector<std::vector<char *>> vList;
    mList.reserve(deviceCount);
    tList.reserve(deviceCount);
    vList.reserve(deviceCount);
    for (int i = 0; i < deviceCount; i++) {
      mList.push_back(toStringVec(measurementsList[i], measurementCounts[i]));
      tList.push_back(toTypeVec(typesList[i], measurementCounts[i]));
      vList.push_back(
          toCharPtrVec(typesList[i], valuesList[i], measurementCounts[i]));
    }
    session->cpp->insertAlignedRecords(devVec, timesVec, mList, tList, vList);
    for (int i = 0; i < deviceCount; i++) {
      freeCharPtrVec(vList[i], typesList[i], measurementCounts[i]);
    }
    return TS_OK;
  } catch (const std::exception &e) {
    return handleException(e);
  }
}

/* ============================================================
 *  Data Insertion  —  Batch, single device (typed values)
 * ============================================================ */

TsStatus ts_session_insert_records_of_one_device(
    CSession *session, const char *deviceId, int rowCount, const int64_t *times,
    const int *measurementCounts, const char *const *const *measurementsList,
    const TSDataType_C *const *typesList, const void *const *const *valuesList,
    bool sorted) {
  clearError();
  if (!session)
    return setError(TS_ERR_NULL_PTR, "session is null");
  try {
    std::vector<int64_t> timesVec(times, times + rowCount);
    std::vector<std::vector<std::string>> mList;
    std::vector<std::vector<TSDataType::TSDataType>> tList;
    std::vector<std::vector<char *>> vList;
    mList.reserve(rowCount);
    tList.reserve(rowCount);
    vList.reserve(rowCount);
    for (int i = 0; i < rowCount; i++) {
      mList.push_back(toStringVec(measurementsList[i], measurementCounts[i]));
      tList.push_back(toTypeVec(typesList[i], measurementCounts[i]));
      vList.push_back(
          toCharPtrVec(typesList[i], valuesList[i], measurementCounts[i]));
    }
    session->cpp->insertRecordsOfOneDevice(std::string(deviceId), timesVec,
                                           mList, tList, vList, sorted);
    for (int i = 0; i < rowCount; i++) {
      freeCharPtrVec(vList[i], typesList[i], measurementCounts[i]);
    }
    return TS_OK;
  } catch (const std::exception &e) {
    return handleException(e);
  }
}

TsStatus ts_session_insert_aligned_records_of_one_device(
    CSession *session, const char *deviceId, int rowCount, const int64_t *times,
    const int *measurementCounts, const char *const *const *measurementsList,
    const TSDataType_C *const *typesList, const void *const *const *valuesList,
    bool sorted) {
  clearError();
  if (!session)
    return setError(TS_ERR_NULL_PTR, "session is null");
  try {
    std::vector<int64_t> timesVec(times, times + rowCount);
    std::vector<std::vector<std::string>> mList;
    std::vector<std::vector<TSDataType::TSDataType>> tList;
    std::vector<std::vector<char *>> vList;
    mList.reserve(rowCount);
    tList.reserve(rowCount);
    vList.reserve(rowCount);
    for (int i = 0; i < rowCount; i++) {
      mList.push_back(toStringVec(measurementsList[i], measurementCounts[i]));
      tList.push_back(toTypeVec(typesList[i], measurementCounts[i]));
      vList.push_back(
          toCharPtrVec(typesList[i], valuesList[i], measurementCounts[i]));
    }
    session->cpp->insertAlignedRecordsOfOneDevice(
        std::string(deviceId), timesVec, mList, tList, vList, sorted);
    for (int i = 0; i < rowCount; i++) {
      freeCharPtrVec(vList[i], typesList[i], measurementCounts[i]);
    }
    return TS_OK;
  } catch (const std::exception &e) {
    return handleException(e);
  }
}

/* ============================================================
 *  Data Insertion  —  Tree Model  (Tablet)
 * ============================================================ */

TsStatus ts_session_insert_tablet(CSession *session, CTablet *tablet,
                                  bool sorted) {
  clearError();
  if (!session)
    return setError(TS_ERR_NULL_PTR, "session is null");
  if (!tablet)
    return setError(TS_ERR_NULL_PTR, "tablet is null");
  try {
    session->cpp->insertTablet(tablet->cpp, sorted);
    return TS_OK;
  } catch (const std::exception &e) {
    return handleException(e);
  }
}

TsStatus ts_session_insert_aligned_tablet(CSession *session, CTablet *tablet,
                                          bool sorted) {
  clearError();
  if (!session)
    return setError(TS_ERR_NULL_PTR, "session is null");
  if (!tablet)
    return setError(TS_ERR_NULL_PTR, "tablet is null");
  try {
    session->cpp->insertAlignedTablet(tablet->cpp, sorted);
    return TS_OK;
  } catch (const std::exception &e) {
    return handleException(e);
  }
}

TsStatus ts_session_insert_tablets(CSession *session, int tabletCount,
                                   const char *const *deviceIds,
                                   CTablet **tablets, bool sorted) {
  clearError();
  if (!session)
    return setError(TS_ERR_NULL_PTR, "session is null");
  try {
    std::unordered_map<std::string, Tablet *> tabletMap;
    for (int i = 0; i < tabletCount; i++) {
      tabletMap[std::string(deviceIds[i])] = &(tablets[i]->cpp);
    }
    session->cpp->insertTablets(tabletMap, sorted);
    return TS_OK;
  } catch (const std::exception &e) {
    return handleException(e);
  }
}

TsStatus ts_session_insert_aligned_tablets(CSession *session, int tabletCount,
                                           const char *const *deviceIds,
                                           CTablet **tablets, bool sorted) {
  clearError();
  if (!session)
    return setError(TS_ERR_NULL_PTR, "session is null");
  try {
    std::unordered_map<std::string, Tablet *> tabletMap;
    for (int i = 0; i < tabletCount; i++) {
      tabletMap[std::string(deviceIds[i])] = &(tablets[i]->cpp);
    }
    session->cpp->insertAlignedTablets(tabletMap, sorted);
    return TS_OK;
  } catch (const std::exception &e) {
    return handleException(e);
  }
}

/* ============================================================
 *  Query  —  Tree Model
 * ============================================================ */

TsStatus ts_session_execute_query(CSession *session, const char *sql,
                                  CSessionDataSet **dataSet) {
  clearError();
  if (!session)
    return setError(TS_ERR_NULL_PTR, "session is null");
  if (!dataSet)
    return setError(TS_ERR_INVALID_PARAM, "dataSet pointer is null");
  try {
    auto ds = session->cpp->executeQueryStatement(std::string(sql));
    CSessionDataSet_ tmp{};
    tmp.cpp = std::move(ds);
    auto *cds = new CSessionDataSet_();
    cds->cpp = std::move(tmp.cpp);
    *dataSet = cds;
    return TS_OK;
  } catch (const std::exception &e) {
    *dataSet = nullptr;
    return handleException(e);
  }
}

TsStatus ts_session_execute_query_with_timeout(CSession *session,
                                               const char *sql,
                                               int64_t timeoutInMs,
                                               CSessionDataSet **dataSet) {
  clearError();
  if (!session)
    return setError(TS_ERR_NULL_PTR, "session is null");
  if (!dataSet)
    return setError(TS_ERR_INVALID_PARAM, "dataSet pointer is null");
  try {
    auto ds =
        session->cpp->executeQueryStatement(std::string(sql), timeoutInMs);
    CSessionDataSet_ tmp{};
    tmp.cpp = std::move(ds);
    auto *cds = new CSessionDataSet_();
    cds->cpp = std::move(tmp.cpp);
    *dataSet = cds;
    return TS_OK;
  } catch (const std::exception &e) {
    *dataSet = nullptr;
    return handleException(e);
  }
}

TsStatus ts_session_execute_non_query(CSession *session, const char *sql) {
  clearError();
  if (!session)
    return setError(TS_ERR_NULL_PTR, "session is null");
  try {
    session->cpp->executeNonQueryStatement(std::string(sql));
    return TS_OK;
  } catch (const std::exception &e) {
    return handleException(e);
  }
}

TsStatus ts_session_execute_raw_data_query(CSession *session, int pathCount,
                                           const char *const *paths,
                                           int64_t startTime, int64_t endTime,
                                           CSessionDataSet **dataSet) {
  clearError();
  if (!session)
    return setError(TS_ERR_NULL_PTR, "session is null");
  if (!dataSet)
    return setError(TS_ERR_INVALID_PARAM, "dataSet pointer is null");
  try {
    auto pathsVec = toStringVec(paths, pathCount);
    auto ds = session->cpp->executeRawDataQuery(pathsVec, startTime, endTime);
    CSessionDataSet_ tmp{};
    tmp.cpp = std::move(ds);
    auto *cds = new CSessionDataSet_();
    cds->cpp = std::move(tmp.cpp);
    *dataSet = cds;
    return TS_OK;
  } catch (const std::exception &e) {
    *dataSet = nullptr;
    return handleException(e);
  }
}

TsStatus ts_session_execute_last_data_query(CSession *session, int pathCount,
                                            const char *const *paths,
                                            CSessionDataSet **dataSet) {
  clearError();
  if (!session)
    return setError(TS_ERR_NULL_PTR, "session is null");
  if (!dataSet)
    return setError(TS_ERR_INVALID_PARAM, "dataSet pointer is null");
  try {
    auto pathsVec = toStringVec(paths, pathCount);
    auto ds = session->cpp->executeLastDataQuery(pathsVec);
    CSessionDataSet_ tmp{};
    tmp.cpp = std::move(ds);
    auto *cds = new CSessionDataSet_();
    cds->cpp = std::move(tmp.cpp);
    *dataSet = cds;
    return TS_OK;
  } catch (const std::exception &e) {
    *dataSet = nullptr;
    return handleException(e);
  }
}

TsStatus ts_session_execute_last_data_query_with_time(
    CSession *session, int pathCount, const char *const *paths,
    int64_t lastTime, CSessionDataSet **dataSet) {
  clearError();
  if (!session)
    return setError(TS_ERR_NULL_PTR, "session is null");
  if (!dataSet)
    return setError(TS_ERR_INVALID_PARAM, "dataSet pointer is null");
  try {
    auto pathsVec = toStringVec(paths, pathCount);
    auto ds = session->cpp->executeLastDataQuery(pathsVec, lastTime);
    CSessionDataSet_ tmp{};
    tmp.cpp = std::move(ds);
    auto *cds = new CSessionDataSet_();
    cds->cpp = std::move(tmp.cpp);
    *dataSet = cds;
    return TS_OK;
  } catch (const std::exception &e) {
    *dataSet = nullptr;
    return handleException(e);
  }
}

/* ============================================================
 *  SessionDataSet & RowRecord  —  Result Iteration
 * ============================================================ */

void ts_dataset_destroy(CSessionDataSet *dataSet) {
  if (dataSet) {
    if (dataSet->cpp) {
      dataSet->cpp->closeOperationHandle();
    }
    delete dataSet;
  }
}

bool ts_dataset_has_next(CSessionDataSet *dataSet) {
  clearError();
  if (!dataSet) {
    (void)setError(TS_ERR_NULL_PTR, "dataSet is null");
    return false;
  }
  if (!dataSet->cpp) {
    (void)setError(TS_ERR_NULL_PTR, "dataSet is not initialized");
    return false;
  }
  try {
    return dataSet->cpp->hasNext();
  } catch (const std::exception &e) {
    (void)handleException(e);
    return false;
  } catch (...) {
    (void)setError(TS_ERR_UNKNOWN, "non-standard exception");
    return false;
  }
}

CRowRecord *ts_dataset_next(CSessionDataSet *dataSet) {
  clearError();
  if (!dataSet) {
    (void)setError(TS_ERR_NULL_PTR, "dataSet is null");
    return nullptr;
  }
  if (!dataSet->cpp) {
    (void)setError(TS_ERR_NULL_PTR, "dataSet is not initialized");
    return nullptr;
  }
  try {
    auto row = dataSet->cpp->next();
    if (!row)
      return nullptr;
    CRowRecord_ tmp{};
    tmp.cpp = std::move(row);
    auto *crr = new CRowRecord_();
    crr->cpp = std::move(tmp.cpp);
    return crr;
  } catch (const std::exception &e) {
    (void)handleException(e);
    return nullptr;
  } catch (...) {
    (void)setError(TS_ERR_UNKNOWN, "non-standard exception");
    return nullptr;
  }
}

int ts_dataset_get_column_count(CSessionDataSet *dataSet) {
  if (!dataSet || !dataSet->cpp)
    return 0;
  return static_cast<int>(dataSet->cpp->getColumnNames().size());
}

static thread_local std::string g_colNameBuf;

const char *ts_dataset_get_column_name(CSessionDataSet *dataSet, int index) {
  if (!dataSet || !dataSet->cpp)
    return "";
  const auto &names = dataSet->cpp->getColumnNames();
  if (index < 0 || index >= (int)names.size())
    return "";
  g_colNameBuf = names[index];
  return g_colNameBuf.c_str();
}

static thread_local std::string g_colTypeBuf;

const char *ts_dataset_get_column_type(CSessionDataSet *dataSet, int index) {
  if (!dataSet || !dataSet->cpp)
    return "";
  const auto &types = dataSet->cpp->getColumnTypeList();
  if (index < 0 || index >= (int)types.size())
    return "";
  g_colTypeBuf = types[index];
  return g_colTypeBuf.c_str();
}

void ts_dataset_set_fetch_size(CSessionDataSet *dataSet, int fetchSize) {
  if (dataSet && dataSet->cpp) {
    dataSet->cpp->setFetchSize(fetchSize);
  }
}

void ts_row_record_destroy(CRowRecord *record) { delete record; }

int64_t ts_row_record_get_timestamp(CRowRecord *record) {
  if (!record || !record->cpp)
    return -1;
  return record->cpp->timestamp;
}

int ts_row_record_get_field_count(CRowRecord *record) {
  if (!record || !record->cpp)
    return 0;
  return static_cast<int>(record->cpp->fields.size());
}

bool ts_row_record_is_null(CRowRecord *record, int index) {
  if (!record || !record->cpp)
    return true;
  if (index < 0 || index >= (int)record->cpp->fields.size())
    return true;
  return record->cpp->fields[index].isNull();
}

bool ts_row_record_get_bool(CRowRecord *record, int index) {
  if (!record || !record->cpp)
    return false;
  if (index < 0 || index >= (int)record->cpp->fields.size())
    return false;
  const Field &f = record->cpp->fields[index];
  return f.boolV.is_initialized() ? f.boolV.value() : false;
}

int32_t ts_row_record_get_int32(CRowRecord *record, int index) {
  if (!record || !record->cpp)
    return 0;
  if (index < 0 || index >= (int)record->cpp->fields.size())
    return 0;
  const Field &f = record->cpp->fields[index];
  return f.intV.is_initialized() ? f.intV.value() : 0;
}

int64_t ts_row_record_get_int64(CRowRecord *record, int index) {
  if (!record || !record->cpp)
    return 0;
  if (index < 0 || index >= (int)record->cpp->fields.size())
    return 0;
  const Field &f = record->cpp->fields[index];
  if (f.longV.is_initialized())
    return f.longV.value();
  if (f.intV.is_initialized())
    return f.intV.value();
  if (f.doubleV.is_initialized())
    return static_cast<int64_t>(f.doubleV.value());
  return 0;
}

float ts_row_record_get_float(CRowRecord *record, int index) {
  if (!record || !record->cpp)
    return 0.0f;
  if (index < 0 || index >= (int)record->cpp->fields.size())
    return 0.0f;
  const Field &f = record->cpp->fields[index];
  return f.floatV.is_initialized() ? f.floatV.value() : 0.0f;
}

double ts_row_record_get_double(CRowRecord *record, int index) {
  if (!record || !record->cpp)
    return 0.0;
  if (index < 0 || index >= (int)record->cpp->fields.size())
    return 0.0;
  const Field &f = record->cpp->fields[index];
  return f.doubleV.is_initialized() ? f.doubleV.value() : 0.0;
}

static thread_local std::string g_stringBuf;

const char *ts_row_record_get_string(CRowRecord *record, int index) {
  if (!record || !record->cpp)
    return "";
  if (index < 0 || index >= (int)record->cpp->fields.size())
    return "";
  const Field &f = record->cpp->fields[index];
  if (f.stringV.is_initialized()) {
    g_stringBuf = f.stringV.value();
    return g_stringBuf.c_str();
  }
  return "";
}

TSDataType_C ts_row_record_get_data_type(CRowRecord *record, int index) {
  if (!record || !record->cpp)
    return TS_TYPE_INVALID;
  if (index < 0 || index >= (int)record->cpp->fields.size())
    return TS_TYPE_INVALID;
  return static_cast<TSDataType_C>(record->cpp->fields[index].dataType);
}

/* ============================================================
 *  Data Deletion  (Tree Model)
 * ============================================================ */

TsStatus ts_session_delete_data(CSession *session, const char *path,
                                int64_t endTime) {
  clearError();
  if (!session)
    return setError(TS_ERR_NULL_PTR, "session is null");
  try {
    session->cpp->deleteData(std::string(path), endTime);
    return TS_OK;
  } catch (const std::exception &e) {
    return handleException(e);
  }
}

TsStatus ts_session_delete_data_batch(CSession *session, int pathCount,
                                      const char *const *paths,
                                      int64_t endTime) {
  clearError();
  if (!session)
    return setError(TS_ERR_NULL_PTR, "session is null");
  try {
    auto pathsVec = toStringVec(paths, pathCount);
    session->cpp->deleteData(pathsVec, endTime);
    return TS_OK;
  } catch (const std::exception &e) {
    return handleException(e);
  }
}

TsStatus ts_session_delete_data_range(CSession *session, int pathCount,
                                      const char *const *paths,
                                      int64_t startTime, int64_t endTime) {
  clearError();
  if (!session)
    return setError(TS_ERR_NULL_PTR, "session is null");
  try {
    auto pathsVec = toStringVec(paths, pathCount);
    session->cpp->deleteData(pathsVec, startTime, endTime);
    return TS_OK;
  } catch (const std::exception &e) {
    return handleException(e);
  }
}

} /* extern "C" */