implement new session constructor

hongzhi-gao · hongzhi-gao · commit c14af5a72716 · 2025-08-25T18:32:41.000+08:00
diff --git a/iotdb-client/client-cpp/src/main/AbstractSessionBuilder.h b/iotdb-client/client-cpp/src/main/AbstractSessionBuilder.h
@@ -35,6 +35,7 @@ class AbstractSessionBuilder {
     bool enableAutoFetch = true;
     bool enableRedirections = true;
     bool enableRPCCompression = false;
+    std::vector<std::string> nodeUrls;
 };
 
 #endif // IOTDB_ABSTRACTSESSIONBUILDER_H
diff --git a/iotdb-client/client-cpp/src/main/Common.cpp b/iotdb-client/client-cpp/src/main/Common.cpp
@@ -454,3 +454,47 @@ const std::vector<char>& BitMap::getByteArray() const {
 size_t BitMap::getSize() const {
     return this->size;
 }
+
+const std::string UrlUtils::PORT_SEPARATOR = ":";
+const std::string UrlUtils::ABB_COLON = "[";
+
+TEndPoint UrlUtils::parseTEndPointIpv4AndIpv6Url(const std::string& endPointUrl) {
+    TEndPoint endPoint;
+
+    // Return default TEndPoint if input is empty
+    if (endPointUrl.empty()) {
+        return endPoint;
+    }
+
+    size_t portSeparatorPos = endPointUrl.find_last_of(PORT_SEPARATOR);
+
+    // If no port separator found, treat entire string as IP
+    if (portSeparatorPos == std::string::npos) {
+        endPoint.__set_ip(endPointUrl);
+        return endPoint;
+    }
+
+    // Extract port part
+    std::string portStr = endPointUrl.substr(portSeparatorPos + 1);
+
+    // Extract IP part
+    std::string ip = endPointUrl.substr(0, portSeparatorPos);
+
+    // Handle IPv6 addresses with brackets
+    if (ip.find(ABB_COLON) != std::string::npos) {
+        // Remove surrounding square brackets for IPv6
+        if (ip.size() >= 2 && ip.front() == '[' && ip.back() == ']') {
+            ip = ip.substr(1, ip.size() - 2);
+        }
+    }
+
+    try {
+        int port = std::stoi(portStr);
+        endPoint.__set_ip(ip);
+        endPoint.__set_port(port);
+    } catch (const std::exception& e) {
+        endPoint.__set_ip(endPointUrl);
+    }
+
+    return endPoint;
+}
diff --git a/iotdb-client/client-cpp/src/main/Common.h b/iotdb-client/client-cpp/src/main/Common.h
@@ -481,5 +481,23 @@ class RpcUtils {
     static std::shared_ptr<TSFetchResultsResp> getTSFetchResultsResp(const TSStatus& status);
 };
 
+class UrlUtils {
+private:
+    static const std::string PORT_SEPARATOR;
+    static const std::string ABB_COLON;
+
+    UrlUtils() = delete;
+    ~UrlUtils() = delete;
+
+public:
+    /**
+     * Parse TEndPoint from a given TEndPointUrl
+     * example:[D80:0000:0000:0000:ABAA:0000:00C2:0002]:22227
+     *
+     * @param endPointUrl ip:port
+     * @return TEndPoint with default values if parse error
+     */
+    static TEndPoint parseTEndPointIpv4AndIpv6Url(const std::string& endPointUrl);
+};
 
 #endif
diff --git a/iotdb-client/client-cpp/src/main/Session.cpp b/iotdb-client/client-cpp/src/main/Session.cpp
@@ -725,18 +725,36 @@ void Session::initZoneId() {
     zoneId_ = zoneStr;
 }
 
-void Session::initNodesSupplier() {
+void Session::initNodesSupplier(const std::vector<std::string>& nodeUrls) {
     std::vector<TEndPoint> endPoints;
-    TEndPoint endPoint;
-    endPoint.__set_ip(host_);
-    endPoint.__set_port(rpcPort_);
-    endPoints.emplace_back(endPoint);
+
+    if (nodeUrls.empty() && host_.empty()) {
+        throw IoTDBException("No available nodes: both nodeUrls and host are empty");
+    }
+
+    // Add local endpoint if nodeUrls is empty or doesn't contain host_
+    if (nodeUrls.empty()) {
+        TEndPoint endPoint;
+        endPoint.__set_ip(host_);
+        endPoint.__set_port(rpcPort_);
+        endPoints.emplace_back(std::move(endPoint));
+    } else {
+        for (auto& url : nodeUrls) {
+            endPoints.emplace_back(UrlUtils::parseTEndPointIpv4AndIpv6Url(url));
+        }
+    }
+
     if (enableAutoFetch_) {
         nodesSupplier_ = NodesSupplier::create(endPoints, username_, password_);
     }
     else {
         nodesSupplier_ = make_shared<StaticNodesSupplier>(endPoints);
     }
+    if (host_.empty()) {
+        auto queryNode = nodesSupplier_->getQueryEndPoint();
+        host_ = queryNode.value().ip;
+        rpcPort_ = queryNode.value().port;
+    }
 }
 
 void Session::initDefaultSessionConnection() {
diff --git a/iotdb-client/client-cpp/src/main/Session.h b/iotdb-client/client-cpp/src/main/Session.h
@@ -535,6 +535,7 @@ class Session {
 private:
     std::string host_;
     int rpcPort_;
+    std::vector<string> nodeUrls_;
     std::string username_;
     std::string password_;
     const TSProtocolVersion::type protocolVersion_ = TSProtocolVersion::IOTDB_SERVICE_PROTOCOL_V3;
@@ -605,7 +606,7 @@ class Session {
 
     void initZoneId();
 
-    void initNodesSupplier();
+    void initNodesSupplier(const std::vector<std::string>& nodeUrls = std::vector<std::string>());
 
     void initDefaultSessionConnection();
 
@@ -664,6 +665,12 @@ class Session {
         initNodesSupplier();
     }
 
+    Session(const std::vector<string>& nodeUrls, const std::string& username, const std::string& password)
+            : nodeUrls_(nodeUrls), username_(username), password_(password), version(Version::V_1_0) {
+        initZoneId();
+        initNodesSupplier(this->nodeUrls_);
+    }
+
     Session(const std::string& host, int rpcPort, const std::string& username, const std::string& password)
         : fetchSize_(DEFAULT_FETCH_SIZE) {
         this->host_ = host;
@@ -714,8 +721,9 @@ class Session {
         this->database_ = builder->database;
         this->enableAutoFetch_ = builder->enableAutoFetch;
         this->enableRedirection_ = builder->enableRedirections;
+        this->nodeUrls_ = builder->nodeUrls;
         initZoneId();
-        initNodesSupplier();
+        initNodesSupplier(this->nodeUrls_);
     }
 
     ~Session();
diff --git a/iotdb-client/client-cpp/src/main/SessionBuilder.h b/iotdb-client/client-cpp/src/main/SessionBuilder.h
@@ -0,0 +1,90 @@
+/*
+ * 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.
+ */
+
+#ifndef IOTDB_SESSION_BUILDER_H
+#define IOTDB_SESSION_BUILDER_H
+
+#include "AbstractSessionBuilder.h"
+
+class SessionBuilder : public AbstractSessionBuilder {
+public:
+    SessionBuilder* host(const std::string &host) {
+        AbstractSessionBuilder::host = host;
+        return this;
+    }
+
+    SessionBuilder* rpcPort(int rpcPort) {
+        AbstractSessionBuilder::rpcPort = rpcPort;
+        return this;
+    }
+
+    SessionBuilder* username(const std::string &username) {
+        AbstractSessionBuilder::username = username;
+        return this;
+    }
+
+    SessionBuilder* password(const std::string &password) {
+        AbstractSessionBuilder::password = password;
+        return this;
+    }
+
+    SessionBuilder* zoneId(const std::string &zoneId) {
+        AbstractSessionBuilder::zoneId = zoneId;
+        return this;
+    }
+
+    SessionBuilder* fetchSize(int fetchSize) {
+        AbstractSessionBuilder::fetchSize = fetchSize;
+        return this;
+    }
+
+    SessionBuilder* database(const std::string &database) {
+        AbstractSessionBuilder::database = database;
+        return this;
+    }
+
+    SessionBuilder* nodeUrls(const std::vector<std::string>& nodeUrls) {
+        AbstractSessionBuilder::nodeUrls = nodeUrls;
+        return this;
+    }
+
+    SessionBuilder* enableAutoFetch(bool enableAutoFetch) {
+        AbstractSessionBuilder::enableAutoFetch = enableAutoFetch;
+        return this;
+    }
+
+    SessionBuilder* enableRedirections(bool enableRedirections) {
+        AbstractSessionBuilder::enableRedirections = enableRedirections;
+        return this;
+    }
+
+    SessionBuilder* enableRPCCompression(bool enableRPCCompression) {
+        AbstractSessionBuilder::enableRPCCompression = enableRPCCompression;
+        return this;
+    }
+
+    Session* build() {
+        sqlDialect = "tree";
+        Session* newSession = new Session(this);
+        newSession->open(false);
+        return new Session(this);
+    }
+};
+
+#endif // IOTDB_SESSION_BUILDER_H
diff --git a/iotdb-client/client-cpp/src/main/TableSessionBuilder.h b/iotdb-client/client-cpp/src/main/TableSessionBuilder.h
@@ -65,6 +65,10 @@ class TableSessionBuilder : public AbstractSessionBuilder {
         AbstractSessionBuilder::database = database;
         return this;
     }
+    TableSessionBuilder* nodeUrls(const std::vector<string>& nodeUrls) {
+        AbstractSessionBuilder::nodeUrls = nodeUrls;
+        return this;
+    }
     TableSession* build() {
         sqlDialect = "table";
         Session* newSession = new Session(this);
diff --git a/iotdb-client/client-cpp/src/test/cpp/sessionIT.cpp b/iotdb-client/client-cpp/src/test/cpp/sessionIT.cpp
@@ -19,6 +19,7 @@
 
 #include "catch.hpp"
 #include "Session.h"
+#include "SessionBuilder.h"
 
 using namespace std;
 
@@ -62,6 +63,42 @@ TEST_CASE("Create timeseries success", "[createTimeseries]") {
     session->deleteTimeseries("root.test.d1.s1");
 }
 
+TEST_CASE("Test Session constructor with nodeUrls", "[SessionInitAndOperate]") {
+    CaseReporter cr("SessionInitWithNodeUrls");
+
+    std::vector<std::string> nodeUrls = {"127.0.0.1:6667"};
+    std::shared_ptr<Session> localSession = std::make_shared<Session>(nodeUrls, "root", "root");
+    localSession->open();
+    if (!localSession->checkTimeseriesExists("root.test.d1.s1")) {
+        localSession->createTimeseries("root.test.d1.s1", TSDataType::INT64, TSEncoding::RLE, CompressionType::SNAPPY);
+    }
+    REQUIRE(localSession->checkTimeseriesExists("root.test.d1.s1") == true);
+    localSession->deleteTimeseries("root.test.d1.s1");
+    localSession->close();
+}
+
+TEST_CASE("Test Session builder with nodeUrls", "[SessionBuilderInit]") {
+    CaseReporter cr("SessionInitWithNodeUrls");
+
+    std::vector<std::string> nodeUrls = {"127.0.0.1:6667"};
+    auto builder = std::unique_ptr<SessionBuilder>(new SessionBuilder());
+    std::shared_ptr<Session> session =
+        std::shared_ptr<Session>(
+            builder
+            ->username("root")
+            ->password("root")
+            ->nodeUrls(nodeUrls)
+            ->build()
+        );
+    session->open();
+    if (!session->checkTimeseriesExists("root.test.d1.s1")) {
+        session->createTimeseries("root.test.d1.s1", TSDataType::INT64, TSEncoding::RLE, CompressionType::SNAPPY);
+    }
+    REQUIRE(session->checkTimeseriesExists("root.test.d1.s1") == true);
+    session->deleteTimeseries("root.test.d1.s1");
+    session->close();
+}
+
 TEST_CASE("Delete timeseries success", "[deleteTimeseries]") {
     CaseReporter cr("deleteTimeseries");
     if (!session->checkTimeseriesExists("root.test.d1.s1")) {
@@ -715,3 +752,62 @@ TEST_CASE("Test executeLastDataQuery ", "[testExecuteLastDataQuery]") {
     sessionDataSet->setFetchSize(1024);
     REQUIRE(sessionDataSet->hasNext() == false);
 }
+
+// Helper function for comparing TEndPoint with detailed error message
+void assertTEndPointEqual(const TEndPoint& actual,
+                         const std::string& expectedIp,
+                         int expectedPort,
+                         const char* file,
+                         int line) {
+    if (actual.ip != expectedIp || actual.port != expectedPort) {
+        std::stringstream ss;
+        ss << "\nTEndPoint mismatch:\nExpected: " << expectedIp << ":" << expectedPort
+           << "\nActual:   " << actual.ip << ":" << actual.port;
+        Catch::SourceLineInfo location(file, line);
+        Catch::AssertionHandler handler("TEndPoint comparison", location, ss.str(), Catch::ResultDisposition::Normal);
+        handler.handleMessage(Catch::ResultWas::ExplicitFailure, ss.str());
+        handler.complete();
+    }
+}
+
+// Macro to simplify test assertions
+#define REQUIRE_TENDPOINT(actual, expectedIp, expectedPort) \
+    assertTEndPointEqual(actual, expectedIp, expectedPort, __FILE__, __LINE__)
+
+TEST_CASE("UrlUtils - parseTEndPointIpv4AndIpv6Url", "[UrlUtils]") {
+    // Test valid IPv4 addresses
+    SECTION("Valid IPv4") {
+        REQUIRE_TENDPOINT(UrlUtils::parseTEndPointIpv4AndIpv6Url("192.168.1.1:8080"), "192.168.1.1", 8080);
+        REQUIRE_TENDPOINT(UrlUtils::parseTEndPointIpv4AndIpv6Url("10.0.0.1:80"), "10.0.0.1", 80);
+    }
+
+    // Test valid IPv6 addresses
+    SECTION("Valid IPv6") {
+        REQUIRE_TENDPOINT(UrlUtils::parseTEndPointIpv4AndIpv6Url("[2001:db8::1]:8080"), "2001:db8::1", 8080);
+        REQUIRE_TENDPOINT(UrlUtils::parseTEndPointIpv4AndIpv6Url("[::1]:80"), "::1", 80);
+    }
+
+    // Test hostnames
+    SECTION("Hostnames") {
+        REQUIRE_TENDPOINT(UrlUtils::parseTEndPointIpv4AndIpv6Url("localhost:8080"), "localhost", 8080);
+        REQUIRE_TENDPOINT(UrlUtils::parseTEndPointIpv4AndIpv6Url("example.com:443"), "example.com", 443);
+    }
+
+    // Test edge cases
+    SECTION("Edge cases") {
+        REQUIRE_TENDPOINT(UrlUtils::parseTEndPointIpv4AndIpv6Url(""), "", 0);
+        REQUIRE_TENDPOINT(UrlUtils::parseTEndPointIpv4AndIpv6Url("127.0.0.1"), "127.0.0.1", 0);
+    }
+
+    // Test invalid inputs
+    SECTION("Invalid inputs") {
+        REQUIRE_TENDPOINT(UrlUtils::parseTEndPointIpv4AndIpv6Url("192.168.1.1:abc"), "192.168.1.1:abc", 0);
+        REQUIRE_TENDPOINT(UrlUtils::parseTEndPointIpv4AndIpv6Url("]invalid[:80"), "]invalid[", 80);
+    }
+
+    // Test port ranges
+    SECTION("Port ranges") {
+        REQUIRE_TENDPOINT(UrlUtils::parseTEndPointIpv4AndIpv6Url("localhost:0"), "localhost", 0);
+        REQUIRE_TENDPOINT(UrlUtils::parseTEndPointIpv4AndIpv6Url("127.0.0.1:65535"), "127.0.0.1", 65535);
+    }
+}
diff --git a/iotdb-client/client-cpp/src/test/cpp/sessionRelationalIT.cpp b/iotdb-client/client-cpp/src/test/cpp/sessionRelationalIT.cpp
