azure-kusto-data/dist-esm/src/response.js

Azure Data Explorer Query SDK

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
import { KustoResultTable, WellKnownDataSet } from "./models.js";
var ErrorLevels;
(function (ErrorLevels) {
    ErrorLevels[ErrorLevels["Warning"] = 3] = "Warning";
    ErrorLevels[ErrorLevels["Error"] = 2] = "Error";
})(ErrorLevels || (ErrorLevels = {}));
export class KustoResponseDataSet {
    constructor(tables) {
        let _tables = tables;
        if (!Array.isArray(tables)) {
            _tables = [tables];
        }
        this.tables = [];
        this.tableNames = [];
        this.primaryResults = [];
        for (const table of _tables) {
            const resultTable = new KustoResultTable(table);
            this.tables.push(resultTable);
            this.tableNames.push(resultTable.name);
            if (resultTable.kind === WellKnownDataSet.PrimaryResult) {
                this.primaryResults.push(resultTable);
            }
            else if (resultTable.kind === WellKnownDataSet.QueryCompletionInformation) {
                this.statusTable = resultTable;
            }
        }
    }
    getErrorsCount() {
        let errors = 0;
        let warnings = 0;
        if (this.statusTable && this.statusTable._rows.length !== 0) {
            let minLevel = ErrorLevels.Error;
            const errorColumn = this.getErrorColumn();
            for (const row of this.statusTable.rows()) {
                if (row[errorColumn] <= minLevel) {
                    if (row[errorColumn] < minLevel) {
                        minLevel = row[errorColumn];
                        errors = 1;
                    }
                    else if (row[errorColumn] === minLevel) {
                        errors += 1;
                    }
                }
                else if (row[errorColumn] === warnings) {
                    warnings += 1;
                }
            }
        }
        if (this.dataSetCompletion && this.dataSetCompletion.HasErrors) {
            errors += 1;
        }
        return { warnings, errors };
    }
    getErrorsByLevel(errorLevel) {
        const result = [];
        if (this.statusTable && this.statusTable._rows.length !== 0) {
            const errorColumn = this.getErrorColumn();
            const cridColumn = this.getCridColumn();
            const statusColumn = this.getStatusColumn();
            for (const row of this.statusTable.rows()) {
                if (row[errorColumn] <= errorLevel) {
                    result.push(`Please provide the following data to Kusto: CRID=${row[cridColumn]} Description: ${row[statusColumn]}`);
                }
            }
        }
        return result;
    }
    getExceptions() {
        const result = this.getErrorsByLevel(ErrorLevels.Error);
        if (this.dataSetCompletion && this.dataSetCompletion.HasErrors && this.dataSetCompletion.OneApiErrors) {
            for (const row of this.dataSetCompletion.OneApiErrors) {
                result.push(row.error["@message"]);
            }
        }
        return result;
    }
    getWarnings() {
        return this.getErrorsByLevel(ErrorLevels.Warning);
    }
}
// TODO: should only expose 1 response type, versioning should be handled internally
export class KustoResponseDataSetV1 extends KustoResponseDataSet {
    getStatusColumn() {
        return "StatusDescription";
    }
    getCridColumn() {
        return "ClientActivityId";
    }
    getErrorColumn() {
        return "Severity";
    }
    static getTablesKinds() {
        return {
            QueryResult: WellKnownDataSet.PrimaryResult,
            QueryProperties: WellKnownDataSet.QueryProperties,
            QueryStatus: WellKnownDataSet.QueryCompletionInformation,
            PrimaryResult: WellKnownDataSet.PrimaryResult,
        };
    }
    constructor(data) {
        super(data.Tables);
        this.dataSetCompletion = null;
        if (this.tables.length <= 2) {
            if (this.tables[0].kind === undefined) {
                this.tables[0].kind = WellKnownDataSet.PrimaryResult;
                this.primaryResults.push(this.tables[0]);
            }
            this.tables[0].id = 0;
            if (this.tables.length === 2) {
                this.tables[1].kind = WellKnownDataSet.QueryProperties;
                this.tables[1].id = 1;
            }
        }
        else {
            const toc = this.tables[this.tables.length - 1];
            toc.kind = WellKnownDataSet.TableOfContents;
            toc.id = this.tables.length - 1;
            for (let i = 0; i < this.tables.length - 1; i++) {
                const current = toc[i];
                this.tables[i].name = current.Name;
                this.tables[i].id = current.Id;
                this.tables[i].kind = KustoResponseDataSetV1.getTablesKinds()[current.Kind];
                if (this.tables[i].kind === WellKnownDataSet.PrimaryResult) {
                    this.primaryResults.push(this.tables[i]);
                }
            }
        }
        this.version = "1.0";
    }
}
// TODO: should only expose 1 response type, versioning should be handled internally
export class KustoResponseDataSetV2 extends KustoResponseDataSet {
    getStatusColumn() {
        return "Payload";
    }
    getErrorColumn() {
        return "Level";
    }
    getCridColumn() {
        return "ClientRequestId";
    }
    constructor(data) {
        const dataTables = [];
        let dataSetHeader = null;
        let dataSetCompletion = null;
        data.forEach((frame) => {
            switch (frame.FrameType) {
                case "DataTable":
                    dataTables.push(frame);
                    break;
                case "DataSetHeader":
                    dataSetHeader = frame;
                    break;
                case "DataSetCompletion":
                    dataSetCompletion = frame;
                    break;
            }
        });
        super(dataTables);
        this.dataSetHeader = dataSetHeader;
        this.dataSetCompletion = dataSetCompletion;
        this.version = "2.0";
    }
}
//# sourceMappingURL=response.js.map