ydb-embedded-ui 4.33.0 → 5.1.0

package/dist/types/api/schema/table.d.ts

@@ -0,0 +1,567 @@
+import type { TCdcStreamDescription } from './cdcStream';
+import type { TIndexDescription } from './tableIndex';
+import type { EColumnCodec, EUnit, TColumnDescription, TPathID, TStorageSettings } from './shared';
+export interface TTableDescription {
+    Name?: string;
+    /**
+     * @deprecated LocalPathId
+     *
+     * uint64
+     */
+    Id_Deprecated?: string;
+    Columns?: TColumnDescription[];
+    KeyColumnNames?: string[];
+    KeyColumnIds?: number[];
+    /**
+     * Describes uniform partitioning on first key column int on ranges.
+     * The first key column must be of integer type
+     */
+    UniformPartitionsCount?: number;
+    PartitionConfig?: TPartitionConfig;
+    DropColumns?: TColumnDescription[];
+    Path?: string;
+    /** bytes */
+    PartitionRangeBegin?: unknown;
+    /** bytes */
+    PartitionRangeEnd?: unknown;
+    PartitionRangeBeginIsInclusive?: boolean;
+    PartitionRangeEndIsInclusive?: boolean;
+    CopyFromTable?: string;
+    /** Boundaries for non-uniform split */
+    SplitBoundary?: TSplitBoundary[];
+    TableIndexes?: TIndexDescription[];
+    /** uint64 */
+    TableSchemaVersion?: string;
+    PathId?: TPathID;
+    TTLSettings?: TTTLSettings;
+    /**
+     * used with CopyFromTable
+     *
+     * default false
+     */
+    OmitFollowers?: boolean;
+    /** default false */
+    IsBackup?: boolean;
+    CdcStreams?: TCdcStreamDescription[];
+    Sequences?: TSequenceDescription[];
+}
+export interface TTTLSettings {
+    Enabled?: TEnabled;
+    Disabled?: {};
+    UseTiering?: string;
+}
+interface TEnabled {
+    ColumnName?: string;
+    ExpireAfterSeconds?: number;
+    ColumnUnit?: EUnit;
+    SysSettings?: TSysSettings;
+}
+interface TSysSettings {
+    /**
+     * default 3600000000 (1 hour)
+     *
+     * uint64
+     */
+    RunInterval?: string;
+    /**
+     * default 300000000 (5 minutes)
+     *
+     * uint64
+     */
+    RetryInterval?: string;
+    /** default 512000 */
+    BatchMaxBytes?: number;
+    /** default 1 */
+    BatchMinKeys?: number;
+    /** default 256 */
+    BatchMaxKeys?: number;
+    /**
+     * zero means no limit
+     *
+     * default 0
+     */
+    MaxShardsInFlight?: number;
+}
+interface TSplitBoundary {
+    /** A tuple representing full key or key prefix */
+    KeyPrefix?: unknown;
+    /**
+     * Or same as KeyPrefix but already serialized
+     *
+     * bytes
+     */
+    SerializedKeyPrefix?: unknown;
+}
+interface TSequenceDescription {
+    Name?: string;
+    /** sequence path id, assigned by schemeshard */
+    PathId?: TPathID;
+    /**
+     * incremented every time sequence is altered
+     *
+     * uint64
+     */
+    Version?: string;
+    /**
+     * current sequenceshard, assigned by schemeshard
+     *
+     * uint64
+     */
+    SequenceShard?: string;
+    /**
+     * minimum value, defaults to 1 or Min<i64>
+     *
+     * sint64
+     */
+    MinValue?: string;
+    /**
+     * maximum value, defaults to Max<i64> or -1
+     *
+     * sint64
+     */
+    MaxValue?: string;
+    /**
+     * start value, defaults to MinValue
+     *
+     * sint64
+     */
+    StartValue?: string;
+    /**
+     * number of items to cache, defaults to 1
+     *
+     * uint64
+     */
+    Cache?: string;
+    /**
+     * increment at each call, defaults to 1
+     *
+     * sint64
+     */
+    Increment?: string;
+    /** true when cycle on overflow is allowed */
+    Cycle?: boolean;
+}
+export interface TTableStats {
+    /** uint64 */
+    DataSize?: string;
+    /** uint64 */
+    RowCount?: string;
+    /** uint64 */
+    IndexSize?: string;
+    /** uint64 */
+    InMemSize?: string;
+    /**
+     * uint64
+     * unix time in millisec
+     */
+    LastAccessTime?: string;
+    /**
+     * uint64
+     * unix time in millisec
+     */
+    LastUpdateTime?: string;
+    RowCountHistogram?: THistogram;
+    DataSizeHistogram?: THistogram;
+    /** uint64 */
+    ImmediateTxCompleted?: string;
+    /** uint64 */
+    PlannedTxCompleted?: string;
+    /** uint64 */
+    TxRejectedByOverload?: string;
+    /** uint64 */
+    TxRejectedBySpace?: string;
+    /** uint64 */
+    TxCompleteLagMsec?: string;
+    /** uint64 */
+    InFlightTxCount?: string;
+    /** uint64 */
+    RowUpdates?: string;
+    /** uint64 */
+    RowDeletes?: string;
+    /** uint64 */
+    RowReads?: string;
+    /** uint64 */
+    RangeReads?: string;
+    /** uint64 */
+    RangeReadRows?: string;
+    /** uint64 */
+    PartCount?: string;
+    KeyAccessSample?: THistogram;
+    /** uint64 */
+    SearchHeight?: string;
+    /**
+     * uint64
+     * seconds since epoch
+     */
+    LastFullCompactionTs?: string;
+    HasLoanedParts?: boolean;
+}
+interface THistogram {
+    Buckets?: THistogramBucket[];
+}
+interface THistogramBucket {
+    Key?: string;
+    /** uint64 */
+    Value?: string;
+}
+export interface TPartitionConfig {
+    /** One of the predefined policies*/
+    NamedCompactionPolicy?: string;
+    /** Customized policy */
+    CompactionPolicy?: TCompactionPolicy;
+    /** uint64 */
+    FollowerCount?: string;
+    /**
+     * Cache size for the whole tablet including all user and system tables
+     *
+     * uint64
+     */
+    ExecutorCacheSize?: string;
+    /**
+     * if true followers can upgrade to leader, if false followers only handle reads
+     *
+     * default true
+     */
+    AllowFollowerPromotion?: boolean;
+    /**
+     * Maximum size in bytes that is allowed to be read by a single Tx
+     *
+     * uint64
+     */
+    TxReadSizeLimit?: string;
+    /** @deprecated use FollowerGroups */
+    CrossDataCenterFollowerCount?: number;
+    /** for configuring erasure and disk categories */
+    ChannelProfileId?: number;
+    PartitioningPolicy?: TPartitioningPolicy;
+    PipelineConfig?: TPipelineConfig;
+    ColumnFamilies?: TFamilyDescription[];
+    ResourceProfile?: string;
+    DisableStatisticsCalculation?: boolean;
+    /**
+     * Build and use per-part bloom filter for fast key non-existence check
+     *
+     * default false
+     */
+    EnableFilterByKey?: boolean;
+    /**
+     * Commit log faster at the expense of bandwidth for cross-DC
+     *
+     * default true
+     */
+    ExecutorFastLogPolicy?: boolean;
+    StorageRooms?: TStorageRoom[];
+    /**
+     * Use erase cache for faster iteration over erased rows
+     *
+     * default true
+     */
+    EnableEraseCache?: boolean;
+    /**
+     * Minimum number of erased rows worth caching
+     *
+     * default 16
+     */
+    EraseCacheMinRows?: number;
+    /**
+     * Maximum number of bytes to use for cached rows
+     *
+     * default 1MB
+     */
+    EraseCacheMaxBytes?: number;
+    FreezeState?: EFreezeState;
+    ShadowData?: boolean;
+    /** 0 or 1 items */
+    FollowerGroups?: TFollowerGroup[];
+    /** uint64 milliseconds */
+    KeepSnapshotTimeout?: string;
+}
+export interface TFollowerGroup {
+    FollowerCount?: number;
+    AllowLeaderPromotion?: boolean;
+    AllowClientRead?: boolean;
+    AllowedNodeIDs?: number[];
+    /** @deprecated use AllowedDataCenters */
+    AllowedDataCenterNumIDs?: number[];
+    RequireAllDataCenters?: boolean;
+    LocalNodeOnly?: boolean;
+    RequireDifferentNodes?: boolean;
+    FollowerCountPerDataCenter?: boolean;
+    AllowedDataCenters?: string[];
+}
+interface TStorageRoom {
+    RoomId?: number;
+    Explanation?: TChannelPurpose[];
+}
+interface TPipelineConfig {
+    /** default 8 */
+    NumActiveTx?: number;
+    DataTxCacheSize?: number;
+    /** default true */
+    EnableOutOfOrder?: boolean;
+    DisableImmediate?: boolean;
+    EnableSoftUpdates?: boolean;
+}
+interface TFamilyDescription {
+    Id?: number;
+    Room?: number;
+    /** @deprecated use ColumnCodec */
+    Codec?: number;
+    /** @deprecated use ColumnCache */
+    InMemory?: boolean;
+    Name?: string;
+    ColumnCodec?: EColumnCodec;
+    ColumnCache?: EColumnCache;
+    /** @deprecated use StorageConfig */
+    Storage?: EColumnStorage;
+    StorageConfig?: TStorageConfig;
+}
+interface TChannelPurpose {
+    Purpose?: EPurpose;
+    Channel?: number;
+}
+interface TStorageConfig {
+    SysLog?: TStorageSettings;
+    Log?: TStorageSettings;
+    Data?: TStorageSettings;
+    External?: TStorageSettings;
+    DataThreshold?: number;
+    ExternalThreshold?: number;
+}
+interface TPartitioningPolicy {
+    /**
+     * Partition gets split when this threshold is exceeded
+     *
+     * uint64
+     */
+    SizeToSplit?: string;
+    MinPartitionsCount?: number;
+    MaxPartitionsCount?: number;
+    FastSplitSettings?: TFastSplitSettings;
+    SplitByLoadSettings?: TSplitByLoadSettings;
+}
+interface TFastSplitSettings {
+    /** uint64 */
+    SizeThreshold?: string;
+    /** uint64 */
+    RowCountThreshold?: string;
+    CpuPercentageThreshold?: number;
+}
+interface TSplitByLoadSettings {
+    Enabled?: boolean;
+    CpuPercentageThreshold?: number;
+}
+interface TCompactionPolicy {
+    /** uint64 */
+    InMemSizeToSnapshot?: string;
+    /** snapshot inmem state when size AND steps from last snapshot passed */
+    InMemStepsToSnapshot?: number;
+    InMemForceStepsToSnapshot?: number;
+    /** uint64 */
+    InMemForceSizeToSnapshot?: string;
+    /** @deprecated default 0 */
+    InMemCompactionBrokerQueue?: number;
+    /** uint64 default 67108864 */
+    ReadAheadHiThreshold?: string;
+    /** uint64 default 16777216 */
+    ReadAheadLoThreshold?: string;
+    /** default 7168 */
+    MinDataPageSize?: number;
+    /** @deprecated default 0*/
+    SnapBrokerQueue?: number;
+    /** @deprecated default 1*/
+    BackupBrokerQueue?: number;
+    /** default 5 */
+    DefaultTaskPriority?: number;
+    BackgroundSnapshotPolicy?: TBackgroundPolicy;
+    InMemResourceBrokerTask?: string;
+    SnapshotResourceBrokerTask?: string;
+    BackupResourceBrokerTask?: string;
+    /** uint64 */
+    LogOverheadSizeToSnapshot?: string;
+    LogOverheadCountToSnapshot?: number;
+    DroppedRowsPercentToCompact?: number;
+    /** default CompactionStrategyUnset */
+    CompactionStrategy?: ECompactionStrategy;
+    ShardPolicy?: TShardPolicy;
+    KeepEraseMarkers?: boolean;
+    Generation?: TGenerationPolicy[];
+}
+interface TShardPolicy {
+    /**
+     * Adjacent shards smaller than this will be merged
+     *
+     * default 33554432
+     *
+     * uint64
+     */
+    MinShardSize?: string;
+    /**
+     * Shards bigger than this will split in two or more pieces
+     *
+     * default 134217728
+     *
+     * uint64
+     */
+    MaxShardSize?: string;
+    /**
+     * Slices smaller than this will get prioritized compaction
+     *
+     * default 2097152
+     *
+     * uint64
+     */
+    MinSliceSize?: string;
+    /**
+     * Level will be compacted when there are more than this number of slices
+     *
+     * default 256
+     */
+    MaxSlicesPerLevel?: number;
+    /**
+     * Shard will be compacted when there are more than this number of levels
+     *
+     * default 16
+     */
+    MaxTotalLevels?: number;
+    /**
+     * Shard will avoid compacting less than this number of levels
+     *
+     * default 2
+     */
+    MinLevelsToCompact?: number;
+    /**
+     * Level will be compacted when it has X% of its data in upper levels
+     *
+     * default 100
+     */
+    NewDataPercentToCompact?: number;
+    /**
+     * Level will be compacted when it has X% of its rows in upper levels
+     *
+     * default 0
+     */
+    NewRowsPercentToCompact?: number;
+    /**
+     * Resource broker task type for compactions
+     *
+     * default 'compaction_gen1'
+     */
+    ResourceBrokerTask?: string;
+    /**
+     * Base priority for compaction tasks
+     *
+     * default 1000
+     */
+    TaskPriorityBase?: number;
+    /**
+     * Task priority will be increased for every N levels over the minimum
+     *
+     * default 1
+     */
+    TaskPriorityLevelsBoost?: number;
+    /**
+     * Task priority will be decreased for every N bytes of input
+     *
+     * default 4194304
+     *
+     * uint64
+     */
+    TaskPrioritySizePenalty?: string;
+    /**
+     * Part data may be reused, unless it would leave this much garbage
+     *
+     * default 20
+     */
+    MaxGarbagePercentToReuse?: number;
+    /**
+     * Minimum slice that that may be reused
+     *
+     * default 524288
+     *
+     * uint64
+     */
+    MinSliceSizeToReuse?: string;
+}
+interface TGenerationPolicy {
+    GenerationId?: number;
+    /** uint64 */
+    SizeToCompact?: string;
+    CountToCompact?: number;
+    ForceCountToCompact?: number;
+    /** uint64 */
+    ForceSizeToCompact?: string;
+    /** @deprecated */
+    CompactionBrokerQueue?: number;
+    KeepInCache?: boolean;
+    BackgroundCompactionPolicy?: TBackgroundPolicy;
+    ResourceBrokerTask?: string;
+    ExtraCompactionPercent?: number;
+    /** uint64 */
+    ExtraCompactionMinSize?: string;
+    ExtraCompactionExpPercent?: number;
+    /** uint64 */
+    ExtraCompactionExpMaxSize?: string;
+    /** uint64 */
+    UpliftPartSize?: string;
+}
+interface TBackgroundPolicy {
+    /**
+     * How much (in %) of forced compaction criteria should be met to submit background task.
+     *
+     * default 101 - no background compaction by default
+     */
+    Threshold?: number;
+    /**
+     * Base background compaction priority value (less priority means more important task).
+     * Value is used to compute real task priority basing on compaction criteria, time in queue etc.
+     *
+     * default 100
+     */
+    PriorityBase?: number;
+    /**
+     * Submitted background task may become more prioritized over time.
+     * New priority is computed as priority /= max(log(elapsed_seconds) * factor, 1);
+     *
+     * default 1.0
+     *
+     * double
+     */
+    TimeFactor?: number;
+    /** @deprecated default 5*/
+    TaskType?: number;
+    ResourceBrokerTask?: string;
+}
+declare enum EPurpose {
+    SysLog = "SysLog",
+    Log = "Log",
+    Data = "Data",
+    External = "External"
+}
+declare enum EFreezeState {
+    Unspecified = "Unspecified",
+    Freeze = "Freeze",
+    Unfreeze = "Unfreeze"
+}
+declare enum EColumnCache {
+    ColumnCacheNone = "ColumnCacheNone",
+    ColumnCacheOnce = "ColumnCacheOnce",
+    ColumnCacheEver = "ColumnCacheEver"
+}
+declare enum EColumnStorage {
+    ColumnStorage1 = "ColumnStorage1",
+    ColumnStorage2 = "ColumnStorage2",
+    ColumnStorage1Ext1 = "ColumnStorage1Ext1",
+    ColumnStorage1Ext2 = "ColumnStorage1Ext2",
+    ColumnStorage2Ext1 = "ColumnStorage2Ext1",
+    ColumnStorage2Ext2 = "ColumnStorage2Ext2",
+    ColumnStorage1Med2Ext2 = "ColumnStorage1Med2Ext2",
+    ColumnStorage2Med2Ext2 = "ColumnStorage2Med2Ext2",
+    ColumnStorageTest_1_2_1k = "ColumnStorageTest_1_2_1k"
+}
+declare enum ECompactionStrategy {
+    CompactionStrategyUnset = "CompactionStrategyUnset",
+    CompactionStrategyGenerational = "CompactionStrategyGenerational",
+    CompactionStrategySharded = "CompactionStrategySharded"
+}
+export {};

package/dist/types/api/schema/table.js

@@ -0,0 +1,38 @@
+var EPurpose;
+(function (EPurpose) {
+    EPurpose["SysLog"] = "SysLog";
+    EPurpose["Log"] = "Log";
+    EPurpose["Data"] = "Data";
+    EPurpose["External"] = "External";
+})(EPurpose || (EPurpose = {}));
+var EFreezeState;
+(function (EFreezeState) {
+    EFreezeState["Unspecified"] = "Unspecified";
+    EFreezeState["Freeze"] = "Freeze";
+    EFreezeState["Unfreeze"] = "Unfreeze";
+})(EFreezeState || (EFreezeState = {}));
+var EColumnCache;
+(function (EColumnCache) {
+    EColumnCache["ColumnCacheNone"] = "ColumnCacheNone";
+    EColumnCache["ColumnCacheOnce"] = "ColumnCacheOnce";
+    EColumnCache["ColumnCacheEver"] = "ColumnCacheEver";
+})(EColumnCache || (EColumnCache = {}));
+var EColumnStorage;
+(function (EColumnStorage) {
+    EColumnStorage["ColumnStorage1"] = "ColumnStorage1";
+    EColumnStorage["ColumnStorage2"] = "ColumnStorage2";
+    EColumnStorage["ColumnStorage1Ext1"] = "ColumnStorage1Ext1";
+    EColumnStorage["ColumnStorage1Ext2"] = "ColumnStorage1Ext2";
+    EColumnStorage["ColumnStorage2Ext1"] = "ColumnStorage2Ext1";
+    EColumnStorage["ColumnStorage2Ext2"] = "ColumnStorage2Ext2";
+    EColumnStorage["ColumnStorage1Med2Ext2"] = "ColumnStorage1Med2Ext2";
+    EColumnStorage["ColumnStorage2Med2Ext2"] = "ColumnStorage2Med2Ext2";
+    EColumnStorage["ColumnStorageTest_1_2_1k"] = "ColumnStorageTest_1_2_1k";
+})(EColumnStorage || (EColumnStorage = {}));
+var ECompactionStrategy;
+(function (ECompactionStrategy) {
+    ECompactionStrategy["CompactionStrategyUnset"] = "CompactionStrategyUnset";
+    ECompactionStrategy["CompactionStrategyGenerational"] = "CompactionStrategyGenerational";
+    ECompactionStrategy["CompactionStrategySharded"] = "CompactionStrategySharded";
+})(ECompactionStrategy || (ECompactionStrategy = {}));
+export {};

package/dist/types/api/schema/tableIndex.d.ts

@@ -0,0 +1,27 @@
+export interface TIndexDescription {
+    Name?: string;
+    /** uint64 */
+    LocalPathId?: string;
+    Type?: EIndexType;
+    State?: EIndexState;
+    KeyColumnNames?: string[];
+    /** uint64 */
+    SchemaVersion?: string;
+    /** uint64 */
+    PathOwnerId?: string;
+    DataColumnNames?: string[];
+    /** uint64 */
+    DataSize?: string;
+}
+declare enum EIndexType {
+    EIndexTypeInvalid = "EIndexTypeInvalid",
+    EIndexTypeGlobal = "EIndexTypeGlobal",
+    EIndexTypeGlobalAsync = "EIndexTypeGlobalAsync"
+}
+declare enum EIndexState {
+    EIndexStateInvalid = "EIndexStateInvalid",
+    EIndexStateReady = "EIndexStateReady",
+    EIndexStateNotReady = "EIndexStateNotReady",
+    EIndexStateWriteOnly = "EIndexStateWriteOnly"
+}
+export {};

package/dist/types/api/schema/tableIndex.js

@@ -0,0 +1,14 @@
+var EIndexType;
+(function (EIndexType) {
+    EIndexType["EIndexTypeInvalid"] = "EIndexTypeInvalid";
+    EIndexType["EIndexTypeGlobal"] = "EIndexTypeGlobal";
+    EIndexType["EIndexTypeGlobalAsync"] = "EIndexTypeGlobalAsync";
+})(EIndexType || (EIndexType = {}));
+var EIndexState;
+(function (EIndexState) {
+    EIndexState["EIndexStateInvalid"] = "EIndexStateInvalid";
+    EIndexState["EIndexStateReady"] = "EIndexStateReady";
+    EIndexState["EIndexStateNotReady"] = "EIndexStateNotReady";
+    EIndexState["EIndexStateWriteOnly"] = "EIndexStateWriteOnly";
+})(EIndexState || (EIndexState = {}));
+export {};