YDB C++ SDK Import 1

include/ydb-cpp-sdk/client/bsconfig/storage_config.h

@@ -14,17 +14,24 @@ namespace NYdb::inline V3::NStorageConfig {
 struct TFetchStorageConfigResult : public TStatus {
     TFetchStorageConfigResult(
             TStatus&& status,
-            std::string&& config)
+            std::string&& config,
+            std::string&& storage_config)
         : TStatus(std::move(status))
         , Config_(std::move(config))
+        , StorageConfig_(std::move(storage_config))
     {}
 
     const std::string& GetConfig() const {
         return Config_;
     }
 
+    const std::string& GetStorageConfig() const {
+        return StorageConfig_;
+    }
+
 private:
     std::string Config_;
+    std::string StorageConfig_;
 };
 
 using TAsyncFetchStorageConfigResult = NThreading::TFuture<TFetchStorageConfigResult>;
@@ -39,10 +46,14 @@ class TStorageConfigClient {
     ~TStorageConfigClient();
 
     // Replace config
-    TAsyncStatus ReplaceStorageConfig(const std::string& config);
+    TAsyncStatus ReplaceStorageConfig(const std::optional<TString>& yaml_config,
+        const std::optional<TString>& storage_yaml_config,
+        std::optional<bool> switch_dedicated_storage_section,
+        bool dedicated_config_mode);
 
     // Fetch current cluster storage config
-    TAsyncFetchStorageConfigResult FetchStorageConfig(const TStorageConfigSettings& settings = {});
+    TAsyncFetchStorageConfigResult FetchStorageConfig(bool dedicated_storage_section, bool dedicated_cluster_section,
+        const TStorageConfigSettings& settings = {});
 
     // Bootstrap cluster with automatic configuration
     TAsyncStatus BootstrapCluster(const std::string& selfAssemblyUUID);

include/ydb-cpp-sdk/client/debug/client.h

@@ -41,21 +41,35 @@ class TTxProxyPingResult: public TStatus {
     {}
 };
 
+class TActorChainPingResult: public TStatus {
+public:
+    TActorChainPingResult(TStatus&& status)
+        : TStatus(std::move(status))
+    {}
+};
+
 ////////////////////////////////////////////////////////////////////////////////
 
 using TAsyncPlainGrpcPingResult = NThreading::TFuture<TPlainGrpcPingResult>;
 using TAsyncGrpcProxyPingResult = NThreading::TFuture<TGrpcProxyPingResult>;
 using TAsyncKqpProxyPingResult = NThreading::TFuture<TKqpProxyPingResult>;
 using TAsyncSchemeCachePingResult = NThreading::TFuture<TSchemeCachePingResult>;
 using TAsyncTxProxyPingResult = NThreading::TFuture<TTxProxyPingResult>;
+using TAsyncActorChainPingResult = NThreading::TFuture<TActorChainPingResult>;
 
 ////////////////////////////////////////////////////////////////////////////////
 
-struct TPlainGrpcPingSettings : public TOperationRequestSettings<TPlainGrpcPingSettings> {};
-struct TGrpcProxyPingSettings : public TOperationRequestSettings<TGrpcProxyPingSettings> {};
-struct TKqpProxyPingSettings : public TOperationRequestSettings<TKqpProxyPingSettings> {};
-struct TSchemeCachePingSettings : public TOperationRequestSettings<TSchemeCachePingSettings> {};
-struct TTxProxyPingSettings : public TOperationRequestSettings<TTxProxyPingSettings> {};
+struct TPlainGrpcPingSettings : public TSimpleRequestSettings<TPlainGrpcPingSettings> {};
+struct TGrpcProxyPingSettings : public TSimpleRequestSettings<TGrpcProxyPingSettings> {};
+struct TKqpProxyPingSettings : public TSimpleRequestSettings<TKqpProxyPingSettings> {};
+struct TSchemeCachePingSettings : public TSimpleRequestSettings<TSchemeCachePingSettings> {};
+struct TTxProxyPingSettings : public TSimpleRequestSettings<TTxProxyPingSettings> {};
+
+struct TActorChainPingSettings : public TSimpleRequestSettings<TActorChainPingSettings> {
+    FLUENT_SETTING_DEFAULT(size_t, ChainLength, 10);
+    FLUENT_SETTING_DEFAULT(size_t, WorkUsec, 5);
+    FLUENT_SETTING_DEFAULT(bool, NoTailChain, false);
+};
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -75,6 +89,8 @@ class TDebugClient {
     TAsyncSchemeCachePingResult PingSchemeCache(const TSchemeCachePingSettings& settings);
     TAsyncTxProxyPingResult PingTxProxy(const TTxProxyPingSettings& settings);
 
+    TAsyncActorChainPingResult PingActorChain(const TActorChainPingSettings& settings);
+
 private:
     class TImpl;
     std::shared_ptr<TImpl> Impl_;

include/ydb-cpp-sdk/client/query/client.h

@@ -151,6 +151,7 @@ class TSession {
     class TImpl;
 private:
     TSession();
+    TSession(std::shared_ptr<TQueryClient::TImpl> client); // Create broken session
     TSession(std::shared_ptr<TQueryClient::TImpl> client, TSession::TImpl* sessionImpl);
 
     std::shared_ptr<TQueryClient::TImpl> Client_;
@@ -210,7 +211,10 @@ class TExecuteQueryPart : public TStreamPartStatus {
     const TResultSet& GetResultSet() const { return *ResultSet_; }
     TResultSet ExtractResultSet() { return std::move(*ResultSet_); }
 
+    bool HasStats() const { return Stats_.has_value(); }
     const std::optional<TExecStats>& GetStats() const { return Stats_; }
+    TExecStats ExtractStats() const { return std::move(*Stats_); }
+
     const std::optional<TTransaction>& GetTransaction() const { return Transaction_; }
 
     TExecuteQueryPart(TStatus&& status, std::optional<TExecStats>&& queryStats, std::optional<TTransaction>&& tx)

include/ydb-cpp-sdk/client/query/query.h

@@ -76,6 +76,7 @@ struct TExecuteQuerySettings : public TRequestSettings<TExecuteQuerySettings> {
     FLUENT_SETTING_DEFAULT(EStatsMode, StatsMode, EStatsMode::None);
     FLUENT_SETTING_OPTIONAL(bool, ConcurrentResultSets);
     FLUENT_SETTING(std::string, ResourcePool);
+    FLUENT_SETTING_OPTIONAL(std::chrono::milliseconds, StatsCollectPeriod);
 };
 
 struct TBeginTxSettings : public TRequestSettings<TBeginTxSettings> {};

include/ydb-cpp-sdk/client/topic/control_plane.h

@@ -19,7 +19,7 @@ namespace NYdb::inline V3 {
 }
 
 namespace NYdb::inline V3::NTopic {
-    
+
 enum class EMeteringMode : uint32_t {
     Unspecified = 0,
     ReservedCapacity = 1,
@@ -187,6 +187,8 @@ friend struct TAutoPartitioningSettingsBuilder;
         , DownUtilizationPercent_(downUtilizationPercent)
         , UpUtilizationPercent_(upUtilizationPercent) {}
 
+    void SerializeTo(Ydb::Topic::AutoPartitioningSettings& proto) const;
+
     EAutoPartitioningStrategy GetStrategy() const;
     TDuration GetStabilizationWindow() const;
     ui32 GetDownUtilizationPercent() const;
@@ -228,6 +230,8 @@ class TPartitioningSettings {
     {
     }
 
+    void SerializeTo(Ydb::Topic::PartitioningSettings& proto) const;
+
     uint64_t GetMinActivePartitions() const;
     uint64_t GetMaxActivePartitions() const;
     uint64_t GetPartitionCountLimit() const;
@@ -437,8 +441,11 @@ struct TConsumerSettings {
 
     using TAttributes = std::map<std::string, std::string>;
 
-    TConsumerSettings(TSettings& parent): Parent_(parent) {}
+    TConsumerSettings(TSettings& parent) : Parent_(parent) {}
     TConsumerSettings(TSettings& parent, const std::string& name) : ConsumerName_(name), Parent_(parent) {}
+    TConsumerSettings(TSettings& parent, const Ydb::Topic::Consumer& proto);
+
+    void SerializeTo(Ydb::Topic::Consumer& proto) const;
 
     FLUENT_SETTING(std::string, ConsumerName);
     FLUENT_SETTING_DEFAULT(bool, Important, false);
@@ -526,6 +533,11 @@ struct TCreateTopicSettings : public TOperationRequestSettings<TCreateTopicSetti
     using TSelf = TCreateTopicSettings;
     using TAttributes = std::map<std::string, std::string>;
 
+    TCreateTopicSettings() = default;
+    TCreateTopicSettings(const Ydb::Topic::CreateTopicRequest& proto);
+
+    void SerializeTo(Ydb::Topic::CreateTopicRequest& proto) const;
+
     FLUENT_SETTING(TPartitioningSettings, PartitioningSettings);
 
     FLUENT_SETTING_DEFAULT(TDuration, RetentionPeriod, TDuration::Hours(24));

src/api/grpc/ydb_debug_v1.proto

@@ -11,4 +11,5 @@ service DebugService {
     rpc PingKqpProxy(Debug.KqpProxyRequest) returns (Debug.KqpProxyResponse);
     rpc PingSchemeCache(Debug.SchemeCacheRequest) returns (Debug.SchemeCacheResponse);
     rpc PingTxProxy(Debug.TxProxyRequest) returns (Debug.TxProxyResponse);
+    rpc PingActorChain(Debug.ActorChainRequest) returns (Debug.ActorChainResponse);
 }

src/api/protos/ydb_bsconfig.proto

@@ -15,7 +15,10 @@ import "src/api/protos/ydb_operation.proto";
 
 message ReplaceStorageConfigRequest {
     Ydb.Operations.OperationParams operation_params = 1;
-    string yaml_config = 2;
+    optional string yaml_config = 2; // cluster yaml config
+    optional string storage_yaml_config = 3; // dedicated storage yaml config (when dual-config mode is enabled)
+    optional bool switch_dedicated_storage_section = 4; // if filled, can turn on or off dedicated section of YAML config
+    bool dedicated_config_mode = 5; // if true, then user expects system to work in dual-config mode
 }
 
 message ReplaceStorageConfigResponse {
@@ -27,14 +30,17 @@ message ReplaceStorageConfigResult {
 
 message FetchStorageConfigRequest {
     Ydb.Operations.OperationParams operation_params = 1;
+    bool dedicated_storage_section = 2;
+    bool dedicated_cluster_section = 3;
 }
 
 message FetchStorageConfigResponse {
     Ydb.Operations.Operation operation = 1;
 }
 
 message FetchStorageConfigResult {
-    string yaml_config = 1;
+    optional string yaml_config = 1;
+    optional string storage_yaml_config = 2;
 }
 
 message BootstrapClusterRequest {

src/api/protos/ydb_debug.proto

@@ -57,3 +57,22 @@ message TxProxyResponse {
     StatusIds.StatusCode status = 1;
     repeated Ydb.Issue.IssueMessage issues = 2;
 }
+
+// Ping Actor Chain
+
+message ActorChainRequest {
+
+    // number of actors to be created, default 10
+    uint32 ChainLength = 1;
+
+    // immitate work duration for each actor (approximate), default ~ 5 usec
+    uint32 WorkUsec = 2;
+
+    // don't use tail sends and registrations
+    bool NoTailChain = 3;
+}
+
+message ActorChainResponse {
+    StatusIds.StatusCode status = 1;
+    repeated Ydb.Issue.IssueMessage issues = 2;
+}

src/api/protos/ydb_query.proto

@@ -174,7 +174,13 @@ message ExecuteQueryRequest {
     // Allows to set size limitation (in bytes) for one result part
     int64 response_part_limit_bytes = 9 [(Ydb.value) = "[0; 33554432]"];
 
-    string pool_id = 10; // Workload manager pool id
+    // Workload manager pool id
+    string pool_id = 10;
+
+    // Time interval for sending periodical query statistics.
+    // When query statistics are enabled (stats_mode != STATS_MODE_NONE), by default statistics will be sent only once after query execution is finished.
+    // In case when stats_period_ms is specified and is non-zero, query statistics will be additionally sent every stats_period_ms milliseconds beginning from the start of query execution.
+    int64 stats_period_ms = 11 [(Ydb.value) = ">= 0"];
 }
 
 message ResultSetMeta {

src/api/protos/ydb_rate_limiter.proto

@@ -63,6 +63,9 @@ message MeteringConfig {
         // Default value is inherited from parent or equals 60 seconds for root.
         uint64 billing_period_sec = 2;
 
+        // User-defined labels.
+        map<string, string> labels = 3 [(map_key).length.le = 256, (length).le = 10240, (size).le = 100];
+
         // Billing metric JSON fields (inherited from parent if not set)
         google.protobuf.Struct metric_fields = 10;
     }

src/client/bsconfig/storage_config.cpp

@@ -14,28 +14,51 @@ class TStorageConfigClient::TImpl : public TClientImplCommon<TStorageConfigClien
     {
     }
 
-    TAsyncStatus ReplaceStorageConfig(const std::string& config) {
+    TAsyncStatus ReplaceStorageConfig(const std::optional<TString>& yaml_config,
+            const std::optional<TString>& storage_yaml_config,
+            std::optional<bool> switch_dedicated_storage_section,
+            bool dedicated_config_mode) {
         auto request = MakeRequest<Ydb::BSConfig::ReplaceStorageConfigRequest>();
-        request.set_yaml_config(config);
+
+        if (yaml_config) {
+            request.set_yaml_config(*yaml_config);
+        }
+        if (storage_yaml_config) {
+            request.set_storage_yaml_config(*storage_yaml_config);
+        }
+        if (switch_dedicated_storage_section) {
+            request.set_switch_dedicated_storage_section(*switch_dedicated_storage_section);
+        }
+        request.set_dedicated_config_mode(dedicated_config_mode);
 
         return RunSimple<Ydb::BSConfig::V1::BSConfigService, Ydb::BSConfig::ReplaceStorageConfigRequest, Ydb::BSConfig::ReplaceStorageConfigResponse>(
             std::move(request),
             &Ydb::BSConfig::V1::BSConfigService::Stub::AsyncReplaceStorageConfig);
     }
 
-    TAsyncFetchStorageConfigResult FetchStorageConfig(const TStorageConfigSettings& settings = {}) {
+    TAsyncFetchStorageConfigResult FetchStorageConfig(bool dedicated_storage_section, bool dedicated_cluster_section,
+			const TStorageConfigSettings& settings = {}) {
         auto request = MakeOperationRequest<Ydb::BSConfig::FetchStorageConfigRequest>(settings);
+        if (dedicated_storage_section) {
+            request.set_dedicated_storage_section(true);
+        }
+        if (dedicated_cluster_section) {
+            request.set_dedicated_cluster_section(true);
+        }
         auto promise = NThreading::NewPromise<TFetchStorageConfigResult>();
 
         auto extractor = [promise] (google::protobuf::Any* any, TPlainStatus status) mutable {
-                NYdb::TStringType config;
-                if (Ydb::BSConfig::FetchStorageConfigResult result; any && any->UnpackTo(&result)) {
-                    config = result.yaml_config();
-                }
-
-                TFetchStorageConfigResult val(TStatus(std::move(status)), std::string{std::move(config)});
-                promise.SetValue(std::move(val));
-            };
+            NYdb::TStringType config;
+            NYdb::TStringType storage_config;
+            if (Ydb::BSConfig::FetchStorageConfigResult result; any && any->UnpackTo(&result)) {
+                config = result.yaml_config();
+                storage_config = result.storage_yaml_config();
+            }
+
+            TFetchStorageConfigResult val(TStatus(std::move(status)), std::string{std::move(config)},
+                std::string{std::move(storage_config)});
+            promise.SetValue(std::move(val));
+        };
 
         Connections_->RunDeferred<Ydb::BSConfig::V1::BSConfigService, Ydb::BSConfig::FetchStorageConfigRequest, Ydb::BSConfig::FetchStorageConfigResponse>(
             std::move(request),
@@ -62,12 +85,16 @@ TStorageConfigClient::TStorageConfigClient(const TDriver& driver, const TCommonC
 
 TStorageConfigClient::~TStorageConfigClient() = default;
 
-TAsyncStatus TStorageConfigClient::ReplaceStorageConfig(const std::string& config) {
-    return Impl_->ReplaceStorageConfig(config);
+TAsyncStatus TStorageConfigClient::ReplaceStorageConfig(const std::optional<TString>& yaml_config,
+        const std::optional<TString>& storage_yaml_config, std::optional<bool> switch_dedicated_storage_section,
+        bool dedicated_config_mode) {
+    return Impl_->ReplaceStorageConfig(yaml_config, storage_yaml_config, switch_dedicated_storage_section,
+        dedicated_config_mode);
 }
 
-TAsyncFetchStorageConfigResult TStorageConfigClient::FetchStorageConfig(const TStorageConfigSettings& settings) {
-    return Impl_->FetchStorageConfig(settings);
+TAsyncFetchStorageConfigResult TStorageConfigClient::FetchStorageConfig(bool dedicated_storage_section,
+        bool dedicated_cluster_section, const TStorageConfigSettings& settings) {
+    return Impl_->FetchStorageConfig(dedicated_storage_section, dedicated_cluster_section, settings);
 }
 
 TAsyncStatus TStorageConfigClient::BootstrapCluster(const std::string& selfAssemblyUUID) {

src/client/debug/client.cpp

@@ -40,6 +40,28 @@ class TDebugClient::TImpl: public TClientImplCommon<TDebugClient::TImpl> {
         return pingPromise;
     }
 
+    auto PingActorChain(const TActorChainPingSettings& settings) {
+        auto pingPromise = NewPromise<TActorChainPingResult>();
+        auto responseCb = [pingPromise] (Debug::ActorChainResponse*, TPlainStatus status) mutable {
+            TActorChainPingResult val(TStatus(std::move(status)));
+            pingPromise.SetValue(std::move(val));
+        };
+
+        Debug::ActorChainRequest request;
+        request.set_chainlength(settings.ChainLength_);
+        request.set_workusec(settings.WorkUsec_);
+        request.set_notailchain(settings.NoTailChain_);
+
+        Connections_->Run<Debug::V1::DebugService, Debug::ActorChainRequest, Debug::ActorChainResponse>(
+            std::move(request),
+            responseCb,
+            &Debug::V1::DebugService::Stub::AsyncPingActorChain,
+            DbDriverState_,
+            TRpcRequestSettings::Make(settings));
+
+        return pingPromise;
+    }
+
     ~TImpl() = default;
 };
 
@@ -73,4 +95,8 @@ TAsyncTxProxyPingResult TDebugClient::PingTxProxy(const TTxProxyPingSettings& se
         settings, &Debug::V1::DebugService::Stub::AsyncPingTxProxy);
 }
 
-} // namespace NYdb::NDebug
+TAsyncActorChainPingResult TDebugClient::PingActorChain(const TActorChainPingSettings& settings) {
+    return Impl_->PingActorChain(settings);
+}
+
+} // namespace NYdb::V3::NDebug