YDB C++ SDK Import 2

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

@@ -36,27 +36,29 @@ struct TFetchStorageConfigResult : public TStatus {
 
 using TAsyncFetchStorageConfigResult = NThreading::TFuture<TFetchStorageConfigResult>;
 
-struct TStorageConfigSettings : public NYdb::TOperationRequestSettings<TStorageConfigSettings> {};
+struct TReplaceStorageConfigSettings : public NYdb::TOperationRequestSettings<TReplaceStorageConfigSettings> {};
+struct TFetchStorageConfigSettings : public NYdb::TOperationRequestSettings<TFetchStorageConfigSettings> {};
+struct TBootstrapClusterSettings : public NYdb::TOperationRequestSettings<TBootstrapClusterSettings> {};
 
 class TStorageConfigClient {
 public:
-
     explicit TStorageConfigClient(const TDriver& driver, const TCommonClientSettings& settings = {});
 
     ~TStorageConfigClient();
 
     // Replace config
-    TAsyncStatus ReplaceStorageConfig(const std::optional<TString>& yaml_config,
-        const std::optional<TString>& storage_yaml_config,
+    TAsyncStatus ReplaceStorageConfig(const std::optional<std::string>& yaml_config,
+        const std::optional<std::string>& storage_yaml_config,
         std::optional<bool> switch_dedicated_storage_section,
-        bool dedicated_config_mode);
+        bool dedicated_config_mode,
+        const TReplaceStorageConfigSettings& settings = {});
 
     // Fetch current cluster storage config
     TAsyncFetchStorageConfigResult FetchStorageConfig(bool dedicated_storage_section, bool dedicated_cluster_section,
-        const TStorageConfigSettings& settings = {});
+        const TFetchStorageConfigSettings& settings = {});
 
     // Bootstrap cluster with automatic configuration
-    TAsyncStatus BootstrapCluster(const std::string& selfAssemblyUUID);
+    TAsyncStatus BootstrapCluster(const std::string& selfAssemblyUUID, const TBootstrapClusterSettings& settings = {});
 
 private:
     class TImpl;

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

@@ -0,0 +1,213 @@
+#pragma once
+
+#include <ydb-cpp-sdk/client/driver/driver.h>
+
+namespace Ydb::Cms {
+    class CreateDatabaseRequest;
+    class ListDatabasesResult;
+    class GetDatabaseStatusResult;
+
+    class StorageUnits;
+    class ComputationalUnits;
+    class AllocatedComputationalUnit;
+    class ServerlessResources;
+    class Resources;
+    class SchemaOperationQuotas;
+    class SchemaOperationQuotas_LeakyBucket;
+    class DatabaseQuotas;
+    class DatabaseQuotas_StorageQuotas;
+    class ScaleRecommenderPolicies;
+    class ScaleRecommenderPolicies_ScaleRecommenderPolicy;
+    class ScaleRecommenderPolicies_ScaleRecommenderPolicy_TargetTrackingPolicy;
+} // namespace Ydb::Cms
+
+namespace NYdb::inline V3::NCms {
+
+struct TListDatabasesSettings : public TOperationRequestSettings<TListDatabasesSettings> {};
+
+class TListDatabasesResult : public TStatus {
+public:
+    TListDatabasesResult(TStatus&& status, const Ydb::Cms::ListDatabasesResult& proto);
+    const std::vector<std::string>& GetPaths() const;
+private:
+    std::vector<std::string> Paths_;
+};
+
+using TAsyncListDatabasesResult = NThreading::TFuture<TListDatabasesResult>;
+
+struct TGetDatabaseStatusSettings : public TOperationRequestSettings<TGetDatabaseStatusSettings> {};
+
+enum class EState {
+    StateUnspecified = 0,
+    Creating = 1,
+    Running = 2,
+    Removing = 3,
+    PendingResources = 4,
+    Configuring = 5,
+};
+
+struct TStorageUnits {
+    TStorageUnits() = default;
+    TStorageUnits(const Ydb::Cms::StorageUnits& proto);
+
+    std::string UnitKind;
+    std::uint64_t Count;
+};
+
+struct TComputationalUnits {
+    TComputationalUnits() = default;
+    TComputationalUnits(const Ydb::Cms::ComputationalUnits& proto);
+
+    std::string UnitKind;
+    std::string AvailabilityZone;
+    std::uint64_t Count;
+};
+
+struct TAllocatedComputationalUnit {
+    TAllocatedComputationalUnit() = default;
+    TAllocatedComputationalUnit(const Ydb::Cms::AllocatedComputationalUnit& proto);
+
+    std::string Host;
+    std::uint32_t Port;
+    std::string UnitKind;
+};
+
+struct TResources {
+    TResources() = default;
+    TResources(const Ydb::Cms::Resources& proto);
+
+    std::vector<TStorageUnits> StorageUnits;
+    std::vector<TComputationalUnits> ComputationalUnits;
+};
+
+struct TSharedResources : public TResources {
+    using TResources::TResources;
+};
+
+struct TServerlessResources {
+    TServerlessResources() = default;
+    TServerlessResources(const Ydb::Cms::ServerlessResources& proto);
+
+    std::string SharedDatabasePath;
+};
+
+struct TSchemaOperationQuotas {
+    struct TLeakyBucket {
+        TLeakyBucket() = default;
+        TLeakyBucket(const Ydb::Cms::SchemaOperationQuotas_LeakyBucket& proto);
+
+        double BucketSize = 1;
+        std::uint64_t BucketSeconds = 2;
+    };
+
+    TSchemaOperationQuotas() = default;
+    TSchemaOperationQuotas(const Ydb::Cms::SchemaOperationQuotas& proto);
+
+    std::vector<TLeakyBucket> LeakyBucketQuotas;
+};
+
+struct TDatabaseQuotas {
+    struct TStorageQuotas {
+        TStorageQuotas() = default;
+        TStorageQuotas(const Ydb::Cms::DatabaseQuotas_StorageQuotas& proto);
+
+        std::string UnitKind;
+        std::uint64_t DataSizeHardQuota;
+        std::uint64_t DataSizeSoftQuota;
+    };
+
+    TDatabaseQuotas() = default;
+    TDatabaseQuotas(const Ydb::Cms::DatabaseQuotas& proto);
+
+    std::uint64_t DataSizeHardQuota;
+    std::uint64_t DataSizeSoftQuota;
+    std::uint64_t DataStreamShardsQuota;
+    std::uint64_t DataStreamReservedStorageQuota;
+    std::uint32_t TtlMinRunInternalSeconds;
+    std::vector<TStorageQuotas> StorageQuotas;
+};
+
+struct TTargetTrackingPolicy {
+    using TAverageCpuUtilizationPercent = std::uint32_t;
+
+    TTargetTrackingPolicy() = default;
+    TTargetTrackingPolicy(const Ydb::Cms::ScaleRecommenderPolicies_ScaleRecommenderPolicy_TargetTrackingPolicy& proto);
+
+    std::variant<std::monostate, TAverageCpuUtilizationPercent> Target;
+};
+
+struct TScaleRecommenderPolicy {
+    TScaleRecommenderPolicy() = default;
+    TScaleRecommenderPolicy(const Ydb::Cms::ScaleRecommenderPolicies_ScaleRecommenderPolicy& proto);
+
+    std::variant<std::monostate, TTargetTrackingPolicy> Policy;
+};
+
+struct TScaleRecommenderPolicies {
+    TScaleRecommenderPolicies() = default;
+    TScaleRecommenderPolicies(const Ydb::Cms::ScaleRecommenderPolicies& proto);
+
+    std::vector<TScaleRecommenderPolicy> Policies;
+};
+
+using TResourcesKind = std::variant<std::monostate, TResources, TSharedResources, TServerlessResources>;
+
+class TGetDatabaseStatusResult : public TStatus {
+public:
+    TGetDatabaseStatusResult(TStatus&& status, const Ydb::Cms::GetDatabaseStatusResult& proto);
+
+    const std::string& GetPath() const;
+    EState GetState() const;
+    const TResourcesKind& GetResourcesKind() const;
+    const TResources& GetAllocatedResources() const;
+    const std::vector<TAllocatedComputationalUnit>& GetRegisteredResources() const;
+    std::uint64_t GetGeneration() const;
+    const TSchemaOperationQuotas& GetSchemaOperationQuotas() const;
+    const TDatabaseQuotas& GetDatabaseQuotas() const;
+    const TScaleRecommenderPolicies& GetScaleRecommenderPolicies() const;
+
+    // Fills CreateDatabaseRequest proto from this database status
+    void SerializeTo(Ydb::Cms::CreateDatabaseRequest& request) const;
+
+private:
+    std::string Path_;
+    EState State_;
+    TResourcesKind ResourcesKind_;
+    TResources AllocatedResources_;
+    std::vector<TAllocatedComputationalUnit> RegisteredResources_;
+    std::uint64_t Generation_;
+    TSchemaOperationQuotas SchemaOperationQuotas_;
+    TDatabaseQuotas DatabaseQuotas_;
+    TScaleRecommenderPolicies ScaleRecommenderPolicies_;
+};
+
+using TAsyncGetDatabaseStatusResult = NThreading::TFuture<TGetDatabaseStatusResult>;
+
+struct TCreateDatabaseSettings : public TOperationRequestSettings<TCreateDatabaseSettings> {
+    TCreateDatabaseSettings() = default;
+    explicit TCreateDatabaseSettings(const Ydb::Cms::CreateDatabaseRequest& request);
+
+    // Fills CreateDatabaseRequest proto from this settings
+    void SerializeTo(Ydb::Cms::CreateDatabaseRequest& request) const;
+
+    FLUENT_SETTING(TResourcesKind, ResourcesKind);
+    FLUENT_SETTING(TSchemaOperationQuotas, SchemaOperationQuotas);
+    FLUENT_SETTING(TDatabaseQuotas, DatabaseQuotas);
+    FLUENT_SETTING(TScaleRecommenderPolicies, ScaleRecommenderPolicies);
+};
+
+class TCmsClient {
+public:
+    explicit TCmsClient(const TDriver& driver, const TCommonClientSettings& settings = TCommonClientSettings());
+
+    TAsyncListDatabasesResult ListDatabases(const TListDatabasesSettings& settings = TListDatabasesSettings());
+    TAsyncGetDatabaseStatusResult GetDatabaseStatus(const std::string& path,
+        const TGetDatabaseStatusSettings& settings = TGetDatabaseStatusSettings());
+    TAsyncStatus CreateDatabase(const std::string& path,
+        const TCreateDatabaseSettings& settings = TCreateDatabaseSettings());
+private:
+    class TImpl;
+    std::shared_ptr<TImpl> Impl_;
+};
+
+} // namespace NYdb::inline V3::NCms

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

@@ -4,9 +4,11 @@
 
 namespace Ydb {
 namespace Coordination {
+    class Config;
+    class CreateNodeRequest;
     class DescribeNodeResult;
-    class SemaphoreSession;
     class SemaphoreDescription;
+    class SemaphoreSession;
 }
 }
 
@@ -107,6 +109,8 @@ class TNodeDescription {
     const std::vector<NScheme::TPermissions>& GetEffectivePermissions() const;
     const Ydb::Coordination::DescribeNodeResult& GetProto() const;
 
+    void SerializeTo(Ydb::Coordination::CreateNodeRequest& creationRequest) const;
+
 private:
     struct TImpl;
     std::shared_ptr<TImpl> Impl_;
@@ -189,7 +193,10 @@ struct TNodeSettings : public TOperationRequestSettings<TDerived> {
     FLUENT_SETTING_DEFAULT(ERateLimiterCountersMode, RateLimiterCountersMode, ERateLimiterCountersMode::UNSET);
 };
 
-struct TCreateNodeSettings : public TNodeSettings<TCreateNodeSettings> { };
+struct TCreateNodeSettings : public TNodeSettings<TCreateNodeSettings> {
+    TCreateNodeSettings() = default;
+    TCreateNodeSettings(const Ydb::Coordination::Config& config);
+};
 struct TAlterNodeSettings : public TNodeSettings<TAlterNodeSettings> { };
 struct TDropNodeSettings : public TOperationRequestSettings<TDropNodeSettings> { };
 struct TDescribeNodeSettings : public TOperationRequestSettings<TDescribeNodeSettings> { };

include/ydb-cpp-sdk/client/draft/ydb_dynamic_config.h

@@ -160,6 +160,21 @@ struct TVerboseResolveConfigResult : public TStatus {
 
 using TAsyncVerboseResolveConfigResult = NThreading::TFuture<TVerboseResolveConfigResult>;
 
+struct TFetchStartupConfigResult : public TStatus {
+    TFetchStartupConfigResult(TStatus&& status, std::string&& config)
+        : TStatus(std::move(status))
+        , Config_(std::move(config))
+    {}
+
+    const std::string& GetConfig() const {
+        return Config_;
+    }
+
+private:
+    std::string Config_;
+};
+
+using TAsyncFetchStartupConfigResult = NThreading::TFuture<TFetchStartupConfigResult>;
 
 struct TDynamicConfigClientSettings : public TCommonClientSettingsBase<TDynamicConfigClientSettings> {
     using TSelf = TDynamicConfigClientSettings;
@@ -240,6 +255,9 @@ class TDynamicConfigClient {
         const std::map<uint64_t, std::string>& volatileConfigs,
         const TClusterConfigSettings& settings = {});
 
+    // Fetch startup config
+    TAsyncFetchStartupConfigResult FetchStartupConfig(const TClusterConfigSettings& settings = {});
+
 private:
     std::shared_ptr<TImpl> Impl_;
 };

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

@@ -142,6 +142,7 @@ class TDriver {
     template<typename TExtension>
     void AddExtension(typename TExtension::TParams params = typename TExtension::TParams());
 
+    TDriverConfig GetConfig() const;
 private:
     std::shared_ptr<TGRpcConnectionsImpl> Impl_;
 };

include/ydb-cpp-sdk/client/proto/accessor.h

@@ -43,6 +43,8 @@ class TProtoAccessor {
     static ::google::protobuf::Map<TStringType, Ydb::TypedValue>* GetProtoMapPtr(TParams& params);
     static const Ydb::TableStats::QueryStats& GetProto(const NTable::TQueryStats& queryStats);
     static const Ydb::Table::DescribeTableResult& GetProto(const NTable::TTableDescription& tableDescription);
+    static const Ydb::Table::DescribeExternalDataSourceResult& GetProto(const NTable::TExternalDataSourceDescription&);
+    static const Ydb::Table::DescribeExternalTableResult& GetProto(const NTable::TExternalTableDescription&);
     static const Ydb::Topic::DescribeTopicResult& GetProto(const NYdb::NTopic::TTopicDescription& topicDescription);
     static const Ydb::Topic::DescribeConsumerResult& GetProto(const NYdb::NTopic::TConsumerDescription& consumerDescription);
     static const Ydb::Monitoring::SelfCheckResult& GetProto(const NYdb::NMonitoring::TSelfCheckResult& selfCheckResult);

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

@@ -29,6 +29,7 @@ class TExecStats {
 
     std::optional<std::string> GetPlan() const;
     std::optional<std::string> GetAst() const;
+    std::optional<std::string> GetMeta() const;
 
     TDuration GetTotalDuration() const;
     TDuration GetTotalCpuTime() const;