@malloydata/malloy 0.0.335 → 0.0.337

package/dist/api/foundation/result.js

@@ -0,0 +1,704 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataRecord = exports.DataArray = exports.Result = void 0;
+const model_1 = require("../../model");
+const row_data_utils_1 = require("../../api/row_data_utils");
+const core_1 = require("./core");
+/**
+ * The result of running a Malloy query.
+ *
+ * A `Result` is a `PreparedResult` along with the data retrieved from running the query.
+ */
+class Result extends core_1.PreparedResult {
+    constructor(queryResult, modelDef) {
+        super(queryResult, modelDef);
+        this.inner = queryResult;
+    }
+    get _queryResult() {
+        return this.inner;
+    }
+    /**
+     * @return The result data.
+     */
+    get data() {
+        return new DataArray(this.inner.result, this.resultExplore, undefined, undefined);
+    }
+    get totalRows() {
+        return this.inner.totalRows;
+    }
+    get runStats() {
+        return this.inner.runStats;
+    }
+    get profilingUrl() {
+        return this.inner.profilingUrl;
+    }
+    toJSON() {
+        // DDL statements (INSTALL, LOAD, CREATE SECRET, etc.) don't have a schema,
+        // so we can't call this.data.toJSON() which requires resultExplore.
+        if (!this.hasSchema) {
+            return {
+                queryResult: this.inner,
+                modelDef: this._modelDef,
+            };
+        }
+        // The result rows are converted to JSON separately because they
+        // may contain un-serializable data types.
+        return {
+            queryResult: { ...this.inner, result: this.data.toJSON() },
+            modelDef: this._modelDef,
+        };
+    }
+    static fromJSON({ queryResult, modelDef }) {
+        return new Result(queryResult, modelDef);
+    }
+}
+exports.Result = Result;
+// =============================================================================
+// Data Base Classes
+// =============================================================================
+class Data {
+    constructor(field, parent, parentRecord) {
+        this.parent = parent;
+        this.parentRecord = parentRecord;
+        this._field = field;
+    }
+    get field() {
+        return this._field;
+    }
+    isString() {
+        return this instanceof DataString;
+    }
+    get string() {
+        if (this.isString()) {
+            return this;
+        }
+        throw new Error('Not a string.');
+    }
+    isBoolean() {
+        return this instanceof DataBoolean;
+    }
+    get boolean() {
+        if (this.isBoolean()) {
+            return this;
+        }
+        throw new Error('Not a boolean.');
+    }
+    isNumber() {
+        return this instanceof DataNumber;
+    }
+    get number() {
+        if (this.isNumber()) {
+            return this;
+        }
+        throw new Error('Not a number.');
+    }
+    isTimestamp() {
+        return this instanceof DataTimestamp;
+    }
+    get timestamp() {
+        if (this.isTimestamp()) {
+            return this;
+        }
+        throw new Error('Not a timestamp.');
+    }
+    isDate() {
+        return this instanceof DataDate;
+    }
+    get date() {
+        if (this.isDate()) {
+            return this;
+        }
+        throw new Error('Not a date.');
+    }
+    isNull() {
+        return this instanceof DataNull;
+    }
+    isBytes() {
+        return this instanceof DataBytes;
+    }
+    get bytes() {
+        if (this.isBytes()) {
+            return this;
+        }
+        throw new Error('Not bytes.');
+    }
+    isRecord() {
+        return this instanceof DataRecord;
+    }
+    get record() {
+        if (this.isRecord()) {
+            return this;
+        }
+        throw new Error('Not a record.');
+    }
+    isUnsupported() {
+        return this instanceof DataUnsupported;
+    }
+    get unsupported() {
+        if (this.isUnsupported()) {
+            return this;
+        }
+        throw new Error('Not unsupported.');
+    }
+    isArray() {
+        return this instanceof DataArray;
+    }
+    get array() {
+        if (this.isArray()) {
+            return this;
+        }
+        throw new Error('Not an array.');
+    }
+    isArrayOrRecord() {
+        if (this instanceof DataArray || this instanceof DataRecord) {
+            return this;
+        }
+        throw new Error('No Array or Record');
+    }
+    isScalar() {
+        return true;
+    }
+}
+class ScalarData extends Data {
+    constructor(value, field, parent, parentRecord) {
+        super(field, parent, parentRecord);
+        this._value = value;
+        this._field = field;
+    }
+    get value() {
+        return this._value;
+    }
+    get field() {
+        return this._field;
+    }
+    isScalar() {
+        return this instanceof ScalarData;
+    }
+}
+// =============================================================================
+// Scalar Data Classes
+// =============================================================================
+class DataString extends ScalarData {
+    constructor(value, field, parent, parentRecord) {
+        super(value, field, parent, parentRecord);
+        this._field = field;
+    }
+    get field() {
+        return this._field;
+    }
+    get key() {
+        return this.value;
+    }
+    compareTo(other) {
+        return this.value
+            .toLocaleLowerCase()
+            .localeCompare(other.value.toLocaleLowerCase());
+    }
+}
+class DataUnsupported extends ScalarData {
+    constructor(value, field, parent, parentRecord) {
+        super(value, field, parent, parentRecord);
+        this._field = field;
+    }
+    get field() {
+        return this._field;
+    }
+    get key() {
+        return '<unsupported>';
+    }
+    compareTo(_other) {
+        return 0;
+    }
+}
+class DataBoolean extends ScalarData {
+    constructor(value, field, parent, parentRecord) {
+        super(value, field, parent, parentRecord);
+        this._field = field;
+    }
+    get field() {
+        return this._field;
+    }
+    get key() {
+        return `${this.value}`;
+    }
+    compareTo(other) {
+        if (this.value === other.value) {
+            return 0;
+        }
+        if (this.value) {
+            return 1;
+        }
+        return -1;
+    }
+}
+class DataJSON extends ScalarData {
+    constructor(value, field, parent, parentRecord) {
+        super(value, field, parent, parentRecord);
+        this._field = field;
+    }
+    get field() {
+        return this._field;
+    }
+    get key() {
+        return this.value;
+    }
+    compareTo(other) {
+        const value = this.value.toString();
+        const otherValue = other.toString();
+        if (value === otherValue) {
+            return 0;
+        }
+        else if (value > otherValue) {
+            return 1;
+        }
+        else {
+            return -1;
+        }
+    }
+}
+class DataNumber extends ScalarData {
+    constructor(value, field, parent, parentRecord) {
+        super((0, row_data_utils_1.rowDataToNumber)(value), field, parent, parentRecord);
+        this._field = field;
+    }
+    get field() {
+        return this._field;
+    }
+    get key() {
+        return `${this.value}`;
+    }
+    compareTo(other) {
+        const difference = this.value - other.value;
+        if (difference > 0) {
+            return 1;
+        }
+        else if (difference === 0) {
+            return 0;
+        }
+        return -1;
+    }
+}
+class DataTimestamp extends ScalarData {
+    constructor(value, field, parent, parentRecord) {
+        super(value, field, parent, parentRecord);
+        this._field = field;
+    }
+    get value() {
+        return (0, row_data_utils_1.rowDataToDate)(this._value);
+    }
+    get field() {
+        return this._field;
+    }
+    get key() {
+        return `${this.value.toLocaleString()}`;
+    }
+    compareTo(other) {
+        if (this.value > other.value) {
+            return 1;
+        }
+        else if (this.value < other.value) {
+            return -1;
+        }
+        return 0;
+    }
+}
+class DataDate extends ScalarData {
+    constructor(value, field, parent, parentRecord) {
+        super(value, field, parent, parentRecord);
+        this._field = field;
+    }
+    get value() {
+        return (0, row_data_utils_1.rowDataToDate)(this._value);
+    }
+    get field() {
+        return this._field;
+    }
+    get key() {
+        return `${this.value.toLocaleString()}`;
+    }
+    compareTo(other) {
+        if (this.value > other.value) {
+            return 1;
+        }
+        else if (this.value < other.value) {
+            return -1;
+        }
+        return 0;
+    }
+}
+class DataBytes extends ScalarData {
+    get key() {
+        return this.value.toString();
+    }
+    compareTo(other) {
+        const value = this.value.toString();
+        const otherValue = other.toString();
+        if (value === otherValue) {
+            return 0;
+        }
+        else if (value > otherValue) {
+            return 1;
+        }
+        else {
+            return -1;
+        }
+    }
+}
+class DataNull extends Data {
+    get value() {
+        return null;
+    }
+    get key() {
+        return '<null>';
+    }
+}
+/**
+ * Safe bigint conversion - handles floats that are incorrectly typed as bigint
+ * (e.g., avg() results which should be float but Malloy marks as bigint).
+ */
+function safeRowDataToBigint(value) {
+    const strValue = (0, row_data_utils_1.rowDataToSerializedBigint)(value);
+    if (strValue.includes('.') ||
+        strValue.includes('e') ||
+        strValue.includes('E')) {
+        return (0, row_data_utils_1.rowDataToNumber)(value);
+    }
+    try {
+        return BigInt(strValue);
+    }
+    catch {
+        return (0, row_data_utils_1.rowDataToNumber)(value);
+    }
+}
+/**
+ * Safe bigint serialization - returns number for floats that should stay as numbers.
+ */
+function safeRowDataToSerializedBigint(value) {
+    const strValue = (0, row_data_utils_1.rowDataToSerializedBigint)(value);
+    if (strValue.includes('.') ||
+        strValue.includes('e') ||
+        strValue.includes('E')) {
+        return (0, row_data_utils_1.rowDataToNumber)(value);
+    }
+    return strValue;
+}
+/**
+ * Normalizers for toObject() - returns JS native types (number | bigint, Date)
+ */
+const OBJECT_NORMALIZERS = {
+    number: row_data_utils_1.rowDataToNumber,
+    bigint: safeRowDataToBigint,
+    date: row_data_utils_1.rowDataToDate,
+};
+/**
+ * Normalizers for toJSON() - returns JSON-safe types (number | string, ISO strings)
+ */
+const JSON_NORMALIZERS = {
+    number: row_data_utils_1.rowDataToNumber,
+    bigint: safeRowDataToSerializedBigint,
+    date: (value) => (0, row_data_utils_1.rowDataToDate)(value).toISOString(),
+};
+/**
+ * Walk a QueryData array and normalize values according to the given normalizers.
+ */
+function walkQueryData(data, structDef, normalizers) {
+    return data.map(row => walkQueryDataRow(row, structDef, normalizers));
+}
+/**
+ * Walk a QueryDataRow and normalize values according to the given normalizers.
+ */
+function walkQueryDataRow(row, structDef, normalizers) {
+    var _a;
+    const result = {};
+    for (const fieldDef of structDef.fields) {
+        const fieldName = (_a = fieldDef.as) !== null && _a !== void 0 ? _a : fieldDef.name;
+        const value = row[fieldName];
+        result[fieldName] = walkValue(value, fieldDef, normalizers);
+    }
+    return result;
+}
+/**
+ * Normalize a single value based on its field definition.
+ */
+function walkValue(value, fieldDef, normalizers) {
+    if (value === null || value === undefined) {
+        return null;
+    }
+    // Handle scalar types
+    if (fieldDef.type === 'number') {
+        const numberDef = fieldDef;
+        if (numberDef.numberType === 'bigint') {
+            return normalizers.bigint(value);
+        }
+        return normalizers.number(value);
+    }
+    if (fieldDef.type === 'date' ||
+        fieldDef.type === 'timestamp' ||
+        fieldDef.type === 'timestamptz') {
+        return normalizers.date(value);
+    }
+    if (fieldDef.type === 'string' ||
+        fieldDef.type === 'boolean' ||
+        fieldDef.type === 'json' ||
+        fieldDef.type === 'sql native') {
+        // Pass through as-is (or with minimal conversion for booleans from numbers)
+        if (fieldDef.type === 'boolean' && typeof value === 'number') {
+            return value !== 0;
+        }
+        return value;
+    }
+    // Handle arrays
+    if (fieldDef.type === 'array') {
+        if (!Array.isArray(value)) {
+            return value; // Unexpected, but don't crash
+        }
+        if ((0, model_1.isRepeatedRecord)(fieldDef)) {
+            // Array of records - recurse into each record
+            return value.map(item => walkQueryDataRow(item, fieldDef, normalizers));
+        }
+        else if ((0, model_1.isBasicArray)(fieldDef)) {
+            // Scalar array - normalize each element based on elementTypeDef
+            // Cast needed because QueryValue type doesn't cleanly express scalar arrays
+            const elementType = fieldDef.elementTypeDef;
+            return value.map(item => walkScalarValue(item, elementType, normalizers));
+        }
+    }
+    // Handle records (non-array)
+    if (fieldDef.type === 'record') {
+        if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+            return walkQueryDataRow(value, fieldDef, normalizers);
+        }
+    }
+    // Fallback - pass through
+    return value;
+}
+/**
+ * Normalize a scalar value (not in a row context, e.g., elements of a scalar array).
+ */
+function walkScalarValue(value, typeDef, normalizers) {
+    if (value === null || value === undefined) {
+        return null;
+    }
+    if (typeDef.type === 'number') {
+        const numberDef = typeDef;
+        if (numberDef.numberType === 'bigint') {
+            return normalizers.bigint(value);
+        }
+        return normalizers.number(value);
+    }
+    if (typeDef.type === 'date' ||
+        typeDef.type === 'timestamp' ||
+        typeDef.type === 'timestamptz') {
+        return normalizers.date(value);
+    }
+    if (typeDef.type === 'boolean' && typeof value === 'number') {
+        return value !== 0;
+    }
+    // Handle nested arrays (array of arrays)
+    if (typeDef.type === 'array' && Array.isArray(value)) {
+        if ((0, model_1.isBasicArray)(typeDef)) {
+            const elementType = typeDef.elementTypeDef;
+            return value.map(item => walkScalarValue(item, elementType, normalizers));
+        }
+        else if ((0, model_1.isRepeatedRecord)(typeDef)) {
+            return value.map(item => walkQueryDataRow(item, typeDef, normalizers));
+        }
+    }
+    // Pass through other types
+    return value;
+}
+// =============================================================================
+// DataArray and DataRecord
+// =============================================================================
+function getPath(data, path) {
+    for (const segment of path) {
+        if (typeof segment === 'number') {
+            data = data.array.row(segment);
+        }
+        else {
+            data = data.record.cell(segment);
+        }
+    }
+    return data;
+}
+class DataArray extends Data {
+    constructor(queryData, field, parent, parentRecord) {
+        super(field, parent, parentRecord);
+        this.rowCache = new Map();
+        this.queryData = queryData;
+        this._field = field;
+    }
+    /**
+     * @return The `Explore` that describes the structure of this data.
+     */
+    get field() {
+        return this._field;
+    }
+    /**
+     * @return The raw query data as returned by the database driver.
+     * Values may be in various formats depending on the driver (wrapper objects, strings, etc.).
+     * Use this for passing to mapData() which handles normalization itself.
+     */
+    get rawData() {
+        return this.queryData;
+    }
+    /**
+     * @return Normalized data with JS native types (number | bigint, Date).
+     * Use this for CSV output, tests, and general programmatic access.
+     */
+    toObject() {
+        return walkQueryData(this.queryData, this._field.structDef, OBJECT_NORMALIZERS);
+    }
+    /**
+     * @return Normalized data with JSON-safe types (numbers as number | string, dates as ISO strings).
+     * Use this for JSON serialization.
+     */
+    toJSON() {
+        return walkQueryData(this.queryData, this._field.structDef, JSON_NORMALIZERS);
+    }
+    path(...path) {
+        return getPath(this, path);
+    }
+    row(index) {
+        let record = this.rowCache.get(index);
+        if (!record) {
+            record = new DataRecord(this.queryData[index], index, this.field, this, this.parentRecord);
+            this.rowCache.set(index, record);
+        }
+        return record;
+    }
+    get rowCount() {
+        return this.queryData.length;
+    }
+    get value() {
+        return this.toObject();
+    }
+    [Symbol.iterator]() {
+        let currentIndex = 0;
+        const queryData = this.queryData;
+        const getRow = (index) => this.row(index);
+        return {
+            next() {
+                if (currentIndex < queryData.length) {
+                    return { value: getRow(currentIndex++), done: false };
+                }
+                else {
+                    return { value: undefined, done: true };
+                }
+            },
+        };
+    }
+    async *inMemoryStream() {
+        for (let i = 0; i < this.queryData.length; i++) {
+            yield this.row(i);
+        }
+    }
+}
+exports.DataArray = DataArray;
+class DataRecord extends Data {
+    constructor(queryDataRow, index, field, parent, parentRecord) {
+        super(field, parent, parentRecord);
+        this.cellCache = new Map();
+        this.queryDataRow = queryDataRow;
+        this._field = field;
+        this.index = index;
+    }
+    /**
+     * @return Normalized data with JS native types (number | bigint, Date).
+     * Use this for CSV output, tests, and general programmatic access.
+     */
+    toObject() {
+        return walkQueryDataRow(this.queryDataRow, this._field.structDef, OBJECT_NORMALIZERS);
+    }
+    /**
+     * @return Normalized data with JSON-safe types (numbers as number | string, dates as ISO strings).
+     * Use this for JSON serialization.
+     */
+    toJSON() {
+        return walkQueryDataRow(this.queryDataRow, this._field.structDef, JSON_NORMALIZERS);
+    }
+    path(...path) {
+        return getPath(this, path);
+    }
+    cell(fieldOrName) {
+        const fieldName = typeof fieldOrName === 'string' ? fieldOrName : fieldOrName.name;
+        const field = this._field.getFieldByName(fieldName);
+        let column = this.cellCache.get(fieldName);
+        if (!column) {
+            const value = this.queryDataRow[fieldName];
+            if (value === null) {
+                column = new DataNull(field, this, this);
+            }
+            else if (field.isAtomicField()) {
+                if (field.isBoolean()) {
+                    column = new DataBoolean(value, field, this, this);
+                }
+                else if (field.isDate()) {
+                    column = new DataDate(value, field, this, this);
+                }
+                else if (field.isJSON()) {
+                    column = new DataJSON(value, field, this, this);
+                }
+                else if (field.isTimestamp()) {
+                    column = new DataTimestamp(value, field, this, this);
+                }
+                else if (field.isNumber()) {
+                    column = new DataNumber(value, field, this, this);
+                }
+                else if (field.isString()) {
+                    column = new DataString(value, field, this, this);
+                }
+                else if (field.isUnsupported()) {
+                    column = new DataUnsupported(value, field, this, this);
+                }
+            }
+            else if (field.isExploreField()) {
+                if (Array.isArray(value)) {
+                    column = new DataArray(value, field, this, this);
+                }
+                else {
+                    column = new DataRecord(value, undefined, field, this, this);
+                }
+            }
+            if (column)
+                this.cellCache.set(fieldName, column);
+        }
+        if (column)
+            return column;
+        throw new Error(`Internal Error: could not construct data column for field '${fieldName}'.`);
+    }
+    get value() {
+        throw new Error('Not implemented;');
+    }
+    // Non repeating values show up as DataRecords
+    get field() {
+        return this._field;
+    }
+    // Allow iteration over non repeating values to simplify end user code.
+    [Symbol.iterator]() {
+        let returned = false;
+        const getSelf = () => {
+            return this;
+        };
+        return {
+            next() {
+                if (!returned) {
+                    returned = true;
+                    return {
+                        value: getSelf(),
+                        done: false,
+                    };
+                }
+                else {
+                    return { value: undefined, done: true };
+                }
+            },
+        };
+    }
+}
+exports.DataRecord = DataRecord;
+//# sourceMappingURL=result.js.map