@l-v-yonsama/multi-platform-database-drivers 2.0.0 → 2.1.0

package/built/src/types/drivers/performance/DynamoDbPerformanceTuningContext.d.ts

@@ -0,0 +1,302 @@
+import { QueryCommandInput } from '@aws-sdk/client-dynamodb';
+import { MetricValue, PerformanceTuningContext } from './PerformanceTuningContext';
+import { DynamoDbPerformanceTuningDiagnostic } from './DynamoDbPerformanceTuningDiagnostic';
+export type AnyPerformanceTuningContext = PerformanceTuningContext | DynamoDbPerformanceTuningContext;
+export declare function isDynamoDbPerformanceTuningContext(context: AnyPerformanceTuningContext): context is DynamoDbPerformanceTuningContext;
+export type DynamoDbAccessPath = 'tableQuery' | 'indexQuery' | 'tableScan' | 'indexScan' | 'unknown';
+export type DynamoDbKeyConditionOperator = '=' | '<' | '<=' | '>' | '>=' | 'BETWEEN' | 'begins_with';
+export type DynamoDbAccessPattern = {
+    operation: 'PartiQLSelect' | 'Query' | 'Scan';
+    accessPath: DynamoDbAccessPath;
+    confidence: 'certain' | 'unknown';
+    tableName: string;
+    indexName?: string;
+    indexType?: 'LSI' | 'GSI';
+    partitionKey?: {
+        attributeName: string;
+        operator?: '=' | 'IN';
+        conditionPresent: boolean;
+    };
+    sortKey?: {
+        attributeName: string;
+        operator?: DynamoDbKeyConditionOperator;
+        conditionPresent: boolean;
+    };
+    postReadFilter: {
+        present: boolean;
+        attributes: string[];
+    };
+    projection: {
+        mode: 'allAttributes' | 'allProjectedAttributes' | 'specific';
+        allAttributes: boolean;
+        attributes: string[];
+    };
+    consistentRead: 'eventual' | 'strong' | 'unknown';
+    limit?: number;
+    resultItemLimit?: number;
+    scanForward?: boolean;
+};
+export type DynamoDbAttributeType = 'S' | 'N' | 'B';
+export type DynamoDbKeyAttribute = {
+    attributeName: string;
+    attributeType: DynamoDbAttributeType;
+};
+export type DynamoDbKeySchema = {
+    partitionKey: DynamoDbKeyAttribute;
+    sortKey?: DynamoDbKeyAttribute;
+};
+export type DynamoDbProjection = {
+    projectionType: 'ALL' | 'KEYS_ONLY' | 'INCLUDE' | 'unknown';
+    nonKeyAttributes?: string[];
+};
+export type DynamoDbThroughput = {
+    readCapacityUnits?: number;
+    writeCapacityUnits?: number;
+};
+export type DynamoDbIndexContext = {
+    indexName: string;
+    indexType: 'LSI' | 'GSI';
+    status?: string;
+    keySchema: DynamoDbKeySchema;
+    projection: DynamoDbProjection;
+    itemCount?: MetricValue<number>;
+    indexSizeBytes?: MetricValue<number>;
+    provisionedThroughput?: DynamoDbThroughput;
+    onDemandThroughput?: {
+        maxReadRequestUnits?: number;
+        maxWriteRequestUnits?: number;
+    };
+    warmThroughput?: DynamoDbThroughput;
+};
+export type DynamoDbContributorInsightsStatus = {
+    resource: 'table' | 'gsi';
+    status: string;
+    mode?: string;
+    indexName?: string;
+};
+export type DynamoDbTableContext = {
+    tableName: string;
+    status?: string;
+    billingMode: 'PROVISIONED' | 'PAY_PER_REQUEST' | 'unknown';
+    keySchema: DynamoDbKeySchema;
+    attributeDefinitions: DynamoDbKeyAttribute[];
+    localSecondaryIndexes: DynamoDbIndexContext[];
+    globalSecondaryIndexes: DynamoDbIndexContext[];
+    provisionedThroughput?: DynamoDbThroughput;
+    onDemandThroughput?: {
+        maxReadRequestUnits?: number;
+        maxWriteRequestUnits?: number;
+    };
+    warmThroughput?: DynamoDbThroughput;
+    itemCount?: MetricValue<number>;
+    tableSizeBytes?: MetricValue<number>;
+    tableClass?: string;
+    ttl?: {
+        status: string;
+        attributeName?: string;
+    };
+    contributorInsights: DynamoDbContributorInsightsStatus[];
+};
+export type DynamoDbCapacityAmount = {
+    capacityUnits?: number;
+    readCapacityUnits?: number;
+    writeCapacityUnits?: number;
+};
+export type DynamoDbCapacityBreakdown = {
+    capacityUnits?: number;
+    readCapacityUnits?: number;
+    writeCapacityUnits?: number;
+    table?: DynamoDbCapacityAmount;
+    localSecondaryIndexes?: Record<string, DynamoDbCapacityAmount>;
+    globalSecondaryIndexes?: Record<string, DynamoDbCapacityAmount>;
+};
+export type DynamoDbWorkloadContext = {
+    executionCount?: number;
+    totalClientElapsedTimeMs?: number;
+    averageClientElapsedTimeMs?: number;
+    maxClientElapsedTimeMs?: number;
+    lastClientElapsedTimeMs?: number;
+    capacitySampleCount?: number;
+    totalCapacityUnits?: number;
+    averageCapacityUnits?: number;
+    maxCapacityUnits?: number;
+    lastCapacityUnits?: number;
+    lastReturnedItemCount?: number;
+    lastEvaluatedItemCount?: number;
+    source?: string;
+    lastExecutedAt?: string;
+    readObservationSampleCount?: number;
+    evaluatedCountSampleCount?: number;
+    totalReturnedItemCount?: number;
+    totalEvaluatedItemCount?: number;
+    weightedFilterPassRate?: number;
+    minFilterPassRate?: number;
+    maxFilterPassRate?: number;
+    lastFilterPassRate?: number;
+    boundedObservationCount?: number;
+};
+export type DynamoDbReadObservation = {
+    source: 'sqlHistory' | 'observedRead';
+    observedAt?: string;
+    clientElapsedTimeMs?: number;
+    requestCount?: number;
+    retryCount?: number;
+    returnedItemCount?: number;
+    evaluatedItemCount?: number;
+    filterPassRate?: number;
+    consumedCapacity?: DynamoDbCapacityBreakdown;
+    hasMorePages?: boolean;
+    bounded: boolean;
+    boundDescription?: string;
+    completeness?: 'complete' | 'bounded' | 'unknown';
+};
+export type DynamoDbBenchmarkSample = {
+    run: number;
+    clientElapsedTimeMs: number;
+    requestCount?: number;
+    retryCount?: number;
+    returnedItemCount?: number;
+    evaluatedItemCount?: number;
+    filterPassRate?: number;
+    consumedCapacity?: DynamoDbCapacityBreakdown;
+    completeness: 'complete' | 'bounded' | 'unknown';
+};
+export type DynamoDbBenchmarkSession = {
+    startedAt: string;
+    completedAt: string;
+    requestedRuns: 3 | 5;
+    completedRuns: number;
+    samples: DynamoDbBenchmarkSample[];
+    medianClientElapsedTimeMs: number;
+    averageClientElapsedTimeMs: number;
+    minClientElapsedTimeMs: number;
+    maxClientElapsedTimeMs: number;
+    medianConsumedReadCapacityUnits?: number;
+    averageConsumedReadCapacityUnits?: number;
+    medianReturnedItemCount?: number;
+    medianEvaluatedItemCount?: number;
+    mode?: 'page' | 'completeResult';
+    completeness?: 'complete' | 'bounded' | 'unknown' | 'mixed';
+    boundDescription?: string;
+    source: 'performanceTuningBenchmark';
+};
+export type DynamoDbCloudWatchSeries = {
+    metricName: string;
+    statistic: string;
+    unit?: string;
+    scope: 'table' | 'gsi' | 'operation';
+    indexName?: string;
+    operation?: 'Query' | 'Scan' | 'ExecuteStatement';
+    timestamps: string[];
+    values: number[];
+    noData: boolean;
+    source: 'AWS/DynamoDB';
+};
+export type DynamoDbCloudWatchContext = {
+    window: {
+        startTime: string;
+        endTime: string;
+        periodSeconds: number;
+    };
+    series: DynamoDbCloudWatchSeries[];
+};
+export type DynamoDbUnavailableSectionName = 'accessPattern' | 'tableDefinition' | 'cloudWatchMetrics' | 'contributorInsights' | 'observation';
+export type DynamoDbUnavailableSection = {
+    section: DynamoDbUnavailableSectionName;
+    tableName?: string;
+    indexName?: string;
+    reason: string;
+    requiredPermissions?: string[];
+};
+export type DynamoDbServiceContext = {
+    provider: 'AWS';
+    service: 'DynamoDB';
+    region?: string;
+    endpointKind: 'aws' | 'custom';
+    tableName: string;
+    indexName?: string;
+};
+export type DynamoDbStatementContext = {
+    language: 'partiql' | 'dynamodb-query';
+    text?: string;
+    source: 'sqlHistory' | 'editor';
+    kind: 'select' | 'query';
+    observationEligibility: {
+        allowed: boolean;
+        reason?: string;
+    };
+};
+export type DynamoDbPerformanceTuningContext = {
+    formatVersion: 1;
+    engine: 'dynamodb';
+    service: DynamoDbServiceContext;
+    statement: DynamoDbStatementContext;
+    accessPattern: DynamoDbAccessPattern;
+    benchmark?: DynamoDbBenchmarkSession;
+    table: DynamoDbTableContext;
+    workload?: DynamoDbWorkloadContext;
+    observation?: DynamoDbReadObservation;
+    cloudWatch?: DynamoDbCloudWatchContext;
+    collection: {
+        collectedAt: string;
+        status: 'complete' | 'partial';
+        diagnostics: DynamoDbPerformanceTuningDiagnostic[];
+        unavailableSections: DynamoDbUnavailableSection[];
+    };
+};
+export type DynamoDbQueryAnalysisInput = {
+    tableName: string;
+    indexName?: string;
+    keyConditionExpression: string;
+    filterExpression?: string;
+    projectionExpression?: string;
+    select?: 'ALL_ATTRIBUTES' | 'ALL_PROJECTED_ATTRIBUTES' | 'COUNT' | 'SPECIFIC_ATTRIBUTES';
+    expressionAttributeNames?: Record<string, string>;
+    consistentRead?: boolean;
+    scanIndexForward?: boolean;
+    limit?: number;
+    resultItemLimit?: number;
+};
+export type DynamoDbPerformanceTuningContextParams = {
+    statement: {
+        source: 'sqlHistory' | 'editor';
+        request: {
+            kind: 'partiql';
+            text: string;
+        } | {
+            kind: 'query';
+            input: DynamoDbQueryAnalysisInput;
+        };
+        workload?: DynamoDbWorkloadContext;
+        previousObservation?: DynamoDbReadObservation;
+    };
+    target?: {
+        tableName: string;
+        indexName?: string;
+    };
+    metrics?: {
+        lookbackMinutes?: number;
+        periodSeconds?: number;
+    };
+    observation?: {
+        mode?: 'static' | 'executeOnce' | 'executeComplete';
+        allowExecution?: boolean;
+        maxEvaluatedItems?: number;
+        maxPages?: number;
+        timeoutMs?: number;
+    };
+    limits?: {
+        maxPayloadBytes?: number;
+        maxIndexes?: number;
+    };
+};
+export type DynamoDbPerformanceTuningCallOptions = {
+    signal?: AbortSignal;
+    execution?: {
+        kind: 'partiql';
+        parameters?: unknown[];
+    } | {
+        kind: 'query';
+        input: QueryCommandInput;
+    };
+};

package/built/src/types/drivers/performance/DynamoDbPerformanceTuningContext.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDynamoDbPerformanceTuningContext = isDynamoDbPerformanceTuningContext;
+function isDynamoDbPerformanceTuningContext(context) {
+    return 'engine' in context && context.engine === 'dynamodb';
+}
+//# sourceMappingURL=DynamoDbPerformanceTuningContext.js.map

package/built/src/types/drivers/performance/DynamoDbPerformanceTuningContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DynamoDbPerformanceTuningContext.js","sourceRoot":"","sources":["../../../../../src/types/drivers/performance/DynamoDbPerformanceTuningContext.ts"],"names":[],"mappings":";;AAcA,gFAIC;AAJD,SAAgB,kCAAkC,CAChD,OAAoC;IAEpC,OAAO,QAAQ,IAAI,OAAO,IAAI,OAAO,CAAC,MAAM,KAAK,UAAU,CAAC;AAC9D,CAAC"}

package/built/src/types/drivers/performance/DynamoDbPerformanceTuningDiagnostic.d.ts

@@ -0,0 +1,13 @@
+import { DynamoDbUnavailableSectionName } from './DynamoDbPerformanceTuningContext';
+export type DynamoDbPerformanceTuningDiagnosticSeverity = 'info' | 'warning';
+export type DynamoDbPerformanceTuningDiagnosticCode = 'DYNAMODB_FULL_TABLE_SCAN' | 'DYNAMODB_FULL_INDEX_SCAN' | 'DYNAMODB_POST_READ_FILTER' | 'DYNAMODB_ACCESS_PATTERN_UNRESOLVED' | 'DYNAMODB_HIGH_SCANNED_TO_RETURNED' | 'DYNAMODB_READ_THROTTLING_OBSERVED' | 'DYNAMODB_KEY_RANGE_THROTTLING_OBSERVED' | 'DYNAMODB_PROVISIONED_THROTTLING_OBSERVED' | 'DYNAMODB_ON_DEMAND_LIMIT_THROTTLING_OBSERVED' | 'DYNAMODB_ACCOUNT_LIMIT_THROTTLING_OBSERVED' | 'DYNAMODB_OBSERVATION_BOUNDED' | 'DYNAMODB_APPROXIMATE_TABLE_METADATA' | 'DYNAMODB_CLOUDWATCH_NO_DATA' | 'DYNAMODB_MONITORING_COLLECTION_SKIPPED' | 'DYNAMODB_SECTION_COLLECTION_FAILED' | 'DYNAMODB_COLLECTION_TRUNCATED';
+export type DynamoDbPerformanceTuningDiagnostic = {
+    code: DynamoDbPerformanceTuningDiagnosticCode;
+    severity: DynamoDbPerformanceTuningDiagnosticSeverity;
+    affectsCompleteness: boolean;
+    scope: DynamoDbUnavailableSectionName | 'collection';
+    message: string;
+    tableName?: string;
+    indexName?: string;
+    metricName?: string;
+};

package/built/src/types/drivers/performance/DynamoDbPerformanceTuningDiagnostic.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=DynamoDbPerformanceTuningDiagnostic.js.map

package/built/src/types/drivers/performance/DynamoDbPerformanceTuningDiagnostic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DynamoDbPerformanceTuningDiagnostic.js","sourceRoot":"","sources":["../../../../../src/types/drivers/performance/DynamoDbPerformanceTuningDiagnostic.ts"],"names":[],"mappings":""}

package/built/src/types/drivers/performance/PerformanceTuningCapabilities.d.ts

@@ -0,0 +1,17 @@
+export type CapabilityStatus = {
+    available: boolean;
+    message?: string;
+    source?: string;
+    requiredPermissions?: string[];
+};
+export type PerformanceTuningCapabilities = {
+    executionPlan: CapabilityStatus;
+    analyzedExecutionPlan: CapabilityStatus;
+    tableDefinition: CapabilityStatus;
+    optimizerStatistics: CapabilityStatus;
+    physicalHealth: CapabilityStatus;
+};
+export type PerformanceTuningAvailabilityParams = {
+    databaseName: string;
+    schemaName?: string;
+};

package/built/src/types/drivers/performance/PerformanceTuningCapabilities.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=PerformanceTuningCapabilities.js.map

package/built/src/types/drivers/performance/PerformanceTuningCapabilities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PerformanceTuningCapabilities.js","sourceRoot":"","sources":["../../../../../src/types/drivers/performance/PerformanceTuningCapabilities.ts"],"names":[],"mappings":""}

package/built/src/types/drivers/performance/PerformanceTuningContext.d.ts

@@ -0,0 +1,263 @@
+import { PerformanceTuningDiagnostic } from './PerformanceTuningDiagnostic';
+import { PlanNode } from './PlanNode';
+export type PerformanceTuningCallOptions = {
+    signal?: AbortSignal;
+};
+export type PerformanceTuningContextParams = {
+    databaseName: string;
+    schemaName?: string;
+    statement: {
+        sql: string;
+        source: 'statementStatistics' | 'sqlHistory' | 'editor';
+        normalizedSql?: string;
+        statistics?: SelectedStatementStatistics;
+    };
+    plan: {
+        mode?: 'estimate' | 'analyze';
+        binds?: unknown[];
+        bindMarkers?: string[];
+        bindMetadata?: Array<{
+            type?: string;
+            selectivityClass?: string;
+        }>;
+        allowExecution?: boolean;
+        timeoutMs?: number;
+    };
+    targetTables?: Array<{
+        schemaName?: string;
+        tableName: string;
+    }>;
+    tableAliasMap?: Record<string, {
+        schemaName?: string;
+        tableName: string;
+    }>;
+    limits?: {
+        maxTables?: number;
+        maxColumnsPerTable?: number;
+        maxIndexesPerTable?: number;
+        maxPayloadBytes?: number;
+    };
+};
+export type DatabaseContext = {
+    vendor: string;
+    version?: string;
+    databaseName: string;
+    schemaName?: string;
+    environment?: string;
+};
+export type StatementContext = {
+    sql: string;
+    source: 'statementStatistics' | 'sqlHistory' | 'editor';
+    kind?: 'select' | 'insert' | 'update' | 'delete' | 'other';
+    analyzeEligibility?: {
+        allowed: boolean;
+        reason?: string;
+    };
+    bindMetadata?: Array<{
+        type?: string;
+        selectivityClass?: string;
+    }>;
+};
+export type WorkloadContext = {
+    statementId?: string;
+    executionCount?: number;
+    totalElapsedTimeMs?: number;
+    averageElapsedTimeMs?: number;
+    minElapsedTimeMs?: number;
+    maxElapsedTimeMs?: number;
+    rowsProcessed?: number;
+    rowsExamined?: number;
+    logicalReads?: number;
+    physicalReads?: number;
+    statisticsSince?: string;
+    lastExecutedAt?: string;
+    source?: string;
+};
+export type SelectedStatementStatistics = WorkloadContext;
+export type PerformanceTuningBenchmarkSample = {
+    run: number;
+    clientElapsedTimeMs: number;
+    returnedRowCount?: number;
+};
+export type PerformanceTuningBenchmarkSession = {
+    startedAt: string;
+    completedAt: string;
+    requestedRuns: 3 | 5;
+    completedRuns: number;
+    samples: PerformanceTuningBenchmarkSample[];
+    medianClientElapsedTimeMs: number;
+    averageClientElapsedTimeMs: number;
+    minClientElapsedTimeMs: number;
+    maxClientElapsedTimeMs: number;
+    planCollectedBeforeBenchmark: true;
+    source: 'performanceTuningBenchmark';
+};
+export type DominantCostPlanNodeRef = {
+    planNodeId: string;
+    metric: 'actual' | 'estimated';
+    exclusiveValue: number;
+};
+export type ActualPlanArtifact = {
+    source: string;
+    format: 'json' | 'text' | 'xml';
+    content: string;
+};
+export type RuntimeObservation = {
+    kind: 'runtimeOperation' | 'missingIndex' | 'memoryGrant' | 'timing' | 'wait';
+    source: string;
+    label: string;
+    detail?: string;
+    schemaName?: string;
+    tableName?: string;
+    operation?: string;
+    metrics?: Record<string, number | string>;
+    columns?: {
+        equality?: string[];
+        inequality?: string[];
+        include?: string[];
+    };
+};
+export type ExecutionPlanContext = {
+    mode: 'estimate' | 'analyze';
+    format: 'json';
+    vendorPlan?: unknown;
+    normalizedPlan?: PlanNode;
+    planningTimeMs?: number;
+    executionTimeMs?: number;
+    actualPlan?: ActualPlanArtifact;
+    runtimeObservations?: RuntimeObservation[];
+    dominantCostPlanNode?: DominantCostPlanNodeRef;
+};
+export type ColumnDefinition = {
+    columnName: string;
+    dataType: string;
+    nullable: boolean;
+    defaultExpression?: string;
+    ordinalPosition?: number;
+    comment?: string;
+};
+export type ConstraintDefinition = {
+    constraintName?: string;
+    type: 'primaryKey' | 'uniqueKey' | 'foreignKey' | 'check';
+    columns?: string[];
+    referencedSchemaName?: string;
+    referencedTableName?: string;
+    referencedColumns?: string[];
+    checkExpression?: string;
+};
+export type IndexColumnDefinition = {
+    columnName?: string;
+    expression?: string;
+    direction?: 'asc' | 'desc';
+    prefixLength?: number;
+};
+export type IndexDefinition = {
+    indexName: string;
+    unique: boolean;
+    primary?: boolean;
+    columns: IndexColumnDefinition[];
+    includedColumns?: string[];
+    predicate?: string;
+    visible?: boolean;
+    enabled?: boolean;
+    indexType?: string;
+};
+export type PartitioningDefinition = {
+    strategy: string;
+    columns?: string[];
+    partitionCount?: number;
+};
+export type TableDefinitionContext = {
+    ddl?: string;
+    columns: ColumnDefinition[];
+    constraints: ConstraintDefinition[];
+    indexes: IndexDefinition[];
+    partitioning?: PartitioningDefinition;
+};
+export type MetricValue<T> = {
+    value: T;
+    estimated: boolean;
+    source: string;
+    unit?: string;
+};
+export type ColumnStatisticsContext = {
+    columnName: string;
+    distinctCount?: MetricValue<number>;
+    distinctFraction?: MetricValue<number>;
+    nullFraction?: MetricValue<number>;
+    averageWidthBytes?: MetricValue<number>;
+    correlation?: MetricValue<number>;
+    histogramType?: MetricValue<string>;
+    histogramBucketCount?: MetricValue<number>;
+    statisticsUpdatedAt?: MetricValue<string>;
+};
+export type TableStatisticsContext = {
+    estimatedRowCount?: MetricValue<number>;
+    tableBytes?: MetricValue<number>;
+    indexBytes?: MetricValue<number>;
+    totalBytes?: MetricValue<number>;
+    statisticsUpdatedAt?: MetricValue<string>;
+    modificationsSinceAnalyze?: MetricValue<number>;
+    sampleRows?: MetricValue<number>;
+    columns: ColumnStatisticsContext[];
+};
+export type PhysicalHealthContext = {
+    provider: string;
+    metrics: Array<{
+        name: string;
+        value: number | string | boolean | null;
+        unit?: string;
+        estimated?: boolean;
+        description?: string;
+    }>;
+};
+export type TableTuningContext = {
+    schemaName?: string;
+    tableName: string;
+    definition?: TableDefinitionContext;
+    statistics?: TableStatisticsContext;
+    physicalHealth?: PhysicalHealthContext;
+};
+export type PlanTableMapping = {
+    planNodeId: string;
+    schemaName?: string;
+    tableName: string;
+    alias?: string;
+    indexName?: string;
+    estimatedRows?: number;
+    actualRows?: number;
+    rowEstimateRatio?: number;
+    tableAccessRows?: MetricValue<number>;
+    predicateFilterInputRows?: MetricValue<number>;
+    predicateFilterOutputRows?: MetricValue<number>;
+    filterColumns?: string[];
+    joinColumns?: string[];
+    groupColumns?: string[];
+    sortColumns?: string[];
+    tableAccessFraction?: MetricValue<number>;
+    predicateFilterSelectivity?: MetricValue<number>;
+};
+export type UnavailableSectionName = 'executionPlan' | 'analyzedExecutionPlan' | 'tableDefinition' | 'tableStatistics' | 'columnStatistics' | 'physicalHealth';
+export type UnavailableSection = {
+    section: UnavailableSectionName;
+    schemaName?: string;
+    tableName?: string;
+    reason: string;
+    requiredPermissions?: string[];
+};
+export type PerformanceTuningContext = {
+    formatVersion: 1;
+    database: DatabaseContext;
+    statement: StatementContext;
+    workload?: WorkloadContext;
+    benchmark?: PerformanceTuningBenchmarkSession;
+    executionPlan: ExecutionPlanContext;
+    tables: TableTuningContext[];
+    planTableMappings: PlanTableMapping[];
+    collection: {
+        collectedAt: string;
+        status: 'complete' | 'partial';
+        diagnostics: PerformanceTuningDiagnostic[];
+        unavailableSections: UnavailableSection[];
+    };
+};

package/built/src/types/drivers/performance/PerformanceTuningContext.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=PerformanceTuningContext.js.map

package/built/src/types/drivers/performance/PerformanceTuningContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PerformanceTuningContext.js","sourceRoot":"","sources":["../../../../../src/types/drivers/performance/PerformanceTuningContext.ts"],"names":[],"mappings":""}

package/built/src/types/drivers/performance/PerformanceTuningDiagnostic.d.ts

@@ -0,0 +1,28 @@
+import { UnavailableSectionName } from './PerformanceTuningContext';
+export type PerformanceTuningDiagnosticSeverity = 'info' | 'warning';
+export type PerformanceTuningDiagnosticScope = 'executionPlan' | 'tableDefinition' | 'tableStatistics' | 'columnStatistics' | 'physicalHealth' | 'collection';
+export type PerformanceTuningDiagnosticCode = 'NON_TABLE_PLAN_SOURCE' | 'PLAN_OBSERVATION' | 'TABLE_MAPPING_FAILED' | 'SECTION_COLLECTION_FAILED' | 'COLLECTION_TRUNCATED' | 'DATABASE_VERSION_UNAVAILABLE' | 'CARDINALITY_MISESTIMATE';
+export type PerformanceTuningDiagnosticNode = {
+    id: string;
+    operation: string;
+    objectKind?: 'function' | 'cte' | 'subquery' | 'values' | 'workTable' | 'table' | 'index';
+    objectName?: string;
+};
+export type PerformanceTuningDiagnostic = {
+    code: PerformanceTuningDiagnosticCode;
+    severity: PerformanceTuningDiagnosticSeverity;
+    affectsCompleteness: boolean;
+    scope: PerformanceTuningDiagnosticScope;
+    message: string;
+    node?: PerformanceTuningDiagnosticNode;
+    schemaName?: string;
+    tableName?: string;
+    section?: UnavailableSectionName;
+    suggestedAction?: string;
+    cardinality?: {
+        estimatedRows: number;
+        actualRows: number;
+        actualToEstimatedRatio: number;
+        candidatePredicateColumns?: string[];
+    };
+};

package/built/src/types/drivers/performance/PerformanceTuningDiagnostic.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=PerformanceTuningDiagnostic.js.map

package/built/src/types/drivers/performance/PerformanceTuningDiagnostic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PerformanceTuningDiagnostic.js","sourceRoot":"","sources":["../../../../../src/types/drivers/performance/PerformanceTuningDiagnostic.ts"],"names":[],"mappings":""}