Add independent HTTP session management and emergency mode settings

Author: yshrhrd

driver/connection.h

@@ -57,6 +57,13 @@ class Connection
     const TypeInfo & getTypeInfo(const std::string & type_name, const std::string & type_name_without_parameters) const;
 
     Poco::URI getUri() const;
+    
+    // Getters for session configuration
+    int getConnectionTimeout() const { return connection_timeout; }
+    int getTimeout() const { return timeout; }
+    const std::string& getProto() const { return proto; }
+    const std::string& getServer() const { return server; }
+    int getPort() const { return port; }
 
     void connect(const std::string & connection_string);
 

driver/statement.cpp

@@ -6,6 +6,9 @@
 
 #include <Poco/Exception.h>
 #include <Poco/Net/HTTPClientSession.h>
+#if !defined(WORKAROUND_DISABLE_SSL)
+#include <Poco/Net/HTTPSClientSession.h>
+#endif
 #include <Poco/Net/HTTPRequest.h>
 #include <Poco/Timezone.h>
 #include <Poco/URI.h>
@@ -19,6 +22,29 @@ Statement::Statement(Connection & connection)
     : ChildType(connection)
 {
     allocateImplicitDescriptors();
+    
+    // Create independent HTTP session for this statement to avoid concurrent access issues
+    auto& conn = getParent();
+    
+#if !defined(WORKAROUND_DISABLE_SSL)
+    const auto is_ssl = (Poco::UTF8::icompare(conn.getProto(), "https") == 0);
+    statement_session = (
+        is_ssl ? std::make_unique<Poco::Net::HTTPSClientSession>() :
+        std::make_unique<Poco::Net::HTTPClientSession>()
+    );
+#else
+    statement_session = std::make_unique<Poco::Net::HTTPClientSession>();
+#endif
+    
+    statement_session->setHost(conn.getServer());
+    statement_session->setPort(conn.getPort());
+    statement_session->setKeepAlive(true);
+    statement_session->setTimeout(
+        Poco::Timespan(conn.getConnectionTimeout(), 0), 
+        Poco::Timespan(conn.getTimeout(), 0), 
+        Poco::Timespan(conn.getTimeout(), 0)
+    );
+    statement_session->setKeepAliveTimeout(Poco::Timespan(86400, 0));
 }
 
 Statement::~Statement() {
@@ -108,9 +134,9 @@ void Statement::requestNextPackOfResultSets(std::unique_ptr<ResultMutator> && mu
 
     auto & connection = getParent();
 
-    if (connection.session && response && in)
+    if (statement_session && response && in)
         if (in->fail() || !in->eof())
-            connection.session->reset();
+            statement_session->reset();
 
     const auto [prepared_query, query_parameters] = prepareHttpRequest();
     Poco::URI uri = connection.getUri();
@@ -142,25 +168,25 @@ void Statement::requestNextPackOfResultSets(std::unique_ptr<ResultMutator> && mu
     for (int i = 1;; ++i) {
         try {
             for (; redirect_count < connection.redirect_limit; ++redirect_count) {
-                connection.session->sendRequest(request) << prepared_query;
+                statement_session->sendRequest(request) << prepared_query;
                 response = std::make_unique<Poco::Net::HTTPResponse>();
-                in = &connection.session->receiveResponse(*response);
+                in = &statement_session->receiveResponse(*response);
                 auto status = response->getStatus();
                 if (status != Poco::Net::HTTPResponse::HTTP_PERMANENT_REDIRECT && status != Poco::Net::HTTPResponse::HTTP_TEMPORARY_REDIRECT) {
                     break;
                 }
-                connection.session->reset(); // reset keepalived connection
+                statement_session->reset(); // reset keepalived connection
                 auto newLocation = response->get("Location");
                 LOG("Redirected to " << newLocation << ", redirect index=" << redirect_count + 1 << "/" << connection.redirect_limit);
                 uri = newLocation;
-                connection.session->setHost(uri.getHost());
-                connection.session->setPort(uri.getPort());
+                statement_session->setHost(uri.getHost());
+                statement_session->setPort(uri.getPort());
                 request.setHost(uri.getHost());
                 request.setURI(uri.getPathEtc());
             }
             break;
         } catch (const Poco::IOException & e) {
-            connection.session->reset(); // reset keepalived connection
+            statement_session->reset(); // reset keepalived connection
             LOG("Http request try=" << i << "/" << connection.retry_count << " failed: " << e.what() << ": " << e.message());
             if (i > connection.retry_count)
                 throw;
@@ -376,9 +402,9 @@ bool Statement::advanceToNextResultSet() {
 
 void Statement::closeCursor() {
     auto & connection = getParent();
-    if (connection.session && response && in) {
+    if (statement_session && response && in) {
         if (in->fail() || !in->eof())
-            connection.session->reset();
+            statement_session->reset();
     }
 
     result_reader.reset();

driver/statement.h

@@ -6,6 +6,7 @@
 #include "driver/result_set.h"
 
 #include <Poco/Net/HTTPResponse.h>
+#include <Poco/Net/HTTPClientSession.h>
 
 #include <memory>
 #include <sstream>
@@ -110,6 +111,9 @@ class Statement
     std::string query;
     std::vector<ParamInfo> parameters;
 
+    // Independent HTTP session for each statement to avoid concurrent access issues
+    std::unique_ptr<Poco::Net::HTTPClientSession> statement_session;
+    
     std::unique_ptr<Poco::Net::HTTPResponse> response;
     std::istream* in = nullptr;
     std::unique_ptr<ResultReader> result_reader;

driver/utils/emergency_mode.h

@@ -0,0 +1,51 @@
+#pragma once
+
+#include "driver/platform/platform.h"
+
+#include <cstdlib>
+#include <string>
+
+namespace emergency_mode {
+
+// MS-ACCESS緊急モード：最小限のメモリ使用
+inline bool isEmergencyMode() {
+    const char* env_val = std::getenv("CLICKHOUSE_ODBC_EMERGENCY_MODE");
+    return (env_val != nullptr && std::string(env_val) == "1");
+}
+
+// 緊急モード用の極小設定
+namespace emergency_settings {
+    constexpr std::size_t MEMORY_POOL_SIZE = 500;     // 500個のみ
+    constexpr std::size_t PREFETCH_ROWS = 1;          // 1行のみ
+    constexpr std::size_t BUFFER_INCREMENT = 32;      // 32バイトずつ
+    constexpr std::size_t MAX_BUFFER_SIZE = 8192;     // 8KB制限
+    constexpr std::size_t MAX_INPUT_SIZE = 4096;      // 4KB制限
+    constexpr std::size_t MAX_ITERATIONS = 20;        // 20回制限
+}
+
+// 緊急モード用の安全な値を取得
+inline std::size_t getSafeMemoryPoolSize() {
+    return isEmergencyMode() ? emergency_settings::MEMORY_POOL_SIZE : 1000;
+}
+
+inline std::size_t getSafePrefetchRows() {
+    return isEmergencyMode() ? emergency_settings::PREFETCH_ROWS : 1;
+}
+
+inline std::size_t getSafeBufferIncrement() {
+    return isEmergencyMode() ? emergency_settings::BUFFER_INCREMENT : 64;
+}
+
+inline std::size_t getSafeMaxBufferSize() {
+    return isEmergencyMode() ? emergency_settings::MAX_BUFFER_SIZE : 32768;
+}
+
+inline std::size_t getSafeMaxInputSize() {
+    return isEmergencyMode() ? emergency_settings::MAX_INPUT_SIZE : 16384;
+}
+
+inline std::size_t getSafeMaxIterations() {
+    return isEmergencyMode() ? emergency_settings::MAX_ITERATIONS : 50;
+}
+
+} // namespace emergency_mode

driver/utils/object_pool.h

@@ -33,6 +33,14 @@ class ObjectPool {
         }
     }
 
+    std::size_t getSize() const {
+        return cache_.size();
+    }
+
+    void clear() {
+        cache_.clear();
+    }
+
 private:
     const std::size_t max_size_;
     std::deque<T> cache_;