@malloydata/malloy 0.0.326 → 0.0.328

package/dist/dialect/standardsql/standardsql.js

@@ -56,8 +56,8 @@ function qtz(qi) {
 const bqToMalloyTypes = {
     'DATE': { type: 'date' },
     'STRING': { type: 'string' },
-    'INTEGER': { type: 'number', numberType: 'integer' },
-    'INT64': { type: 'number', numberType: 'integer' },
+    'INTEGER': { type: 'number', numberType: 'bigint' },
+    'INT64': { type: 'number', numberType: 'bigint' },
     'FLOAT': { type: 'number', numberType: 'float' },
     'FLOAT64': { type: 'number', numberType: 'float' },
     'NUMERIC': { type: 'number', numberType: 'float' },
@@ -97,6 +97,10 @@ class StandardSQLDialect extends dialect_1.Dialect {
         this.nestedArrays = false; // Can't have an array of arrays for some reason
         this.supportsHyperLogLog = true;
         this.likeEscape = false; // Uses \ instead of ESCAPE 'X' in like clauses
+        // BigQuery only has INT64 - all integers can exceed JS Number precision
+        this.integerTypeMappings = [
+            { min: dialect_1.MIN_INT64, max: dialect_1.MAX_INT64, numberType: 'bigint' },
+        ];
     }
     quoteTablePath(tablePath) {
         return `\`${tablePath}\``;
@@ -365,7 +369,8 @@ ${(0, utils_1.indent)(sql)}
     }
     malloyTypeToSQLType(malloyType) {
         if (malloyType.type === 'number') {
-            if (malloyType.numberType === 'integer') {
+            if (malloyType.numberType === 'integer' ||
+                malloyType.numberType === 'bigint') {
                 return 'INT64';
             }
             else {

package/dist/dialect/trino/trino.js

@@ -52,7 +52,7 @@ function qtz(qi) {
 const trinoToMalloyTypes = {
     'varchar': { type: 'string' },
     'integer': { type: 'number', numberType: 'integer' },
-    'bigint': { type: 'number', numberType: 'integer' },
+    'bigint': { type: 'number', numberType: 'bigint' },
     'smallint': { type: 'number', numberType: 'integer' },
     'tinyint': { type: 'number', numberType: 'integer' },
     'double': { type: 'number', numberType: 'float' },
@@ -480,7 +480,15 @@ ${(0, utils_1.indent)(sql)}
     malloyTypeToSQLType(malloyType) {
         switch (malloyType.type) {
             case 'number':
-                return malloyType.numberType === 'integer' ? 'BIGINT' : 'DOUBLE';
+                if (malloyType.numberType === 'integer') {
+                    return 'INTEGER';
+                }
+                else if (malloyType.numberType === 'bigint') {
+                    return 'BIGINT';
+                }
+                else {
+                    return 'DOUBLE';
+                }
             case 'string':
                 return 'VARCHAR';
             case 'timestamptz':

package/dist/lang/ast/expressions/expr-avg.d.ts

@@ -1,6 +1,11 @@
 import type { FieldReference } from '../query-items/field-references';
 import type { ExpressionDef } from '../types/expression-def';
+import type { ExprValue } from '../types/expr-value';
 import { ExprAsymmetric } from './expr-asymmetric';
 export declare class ExprAvg extends ExprAsymmetric {
     constructor(expr: ExpressionDef | undefined, source?: FieldReference, explicitSource?: boolean);
+    /**
+     * avg() always returns a float, regardless of input type.
+     */
+    returns(ev: ExprValue): ExprValue;
 }

package/dist/lang/ast/expressions/expr-avg.js

@@ -29,6 +29,15 @@ class ExprAvg extends expr_asymmetric_1.ExprAsymmetric {
         super('avg', expr, source, explicitSource);
         this.has({ source: source });
     }
+    /**
+     * avg() always returns a float, regardless of input type.
+     */
+    returns(ev) {
+        if (ev.type === 'number') {
+            return { ...ev, numberType: 'float' };
+        }
+        return ev;
+    }
 }
 exports.ExprAvg = ExprAvg;
 //# sourceMappingURL=expr-avg.js.map

package/dist/lang/ast/expressions/expr-coalesce.js

@@ -87,8 +87,14 @@ class ExprCoalesce extends expression_def_1.ExpressionDef {
             this.logError('mismatched-coalesce-types', `Mismatched types for coalesce (${maybeNull.type}, ${whenNull.type})`);
         }
         const srcForType = maybeNull.type === 'error' ? whenNull : maybeNull;
+        // If both are numbers but subtypes differ, strip the subtype
+        const stripNumberType = srcForType.type === 'number' &&
+            maybeNull.type === 'number' &&
+            whenNull.type === 'number' &&
+            maybeNull.numberType !== whenNull.numberType;
         return {
             ...srcForType,
+            ...(stripNumberType ? { numberType: undefined } : {}),
             expressionType: (0, model_1.maxExpressionType)(maybeNull.expressionType, whenNull.expressionType),
             value: {
                 node: 'coalesce',

package/dist/lang/ast/expressions/expr-number.d.ts

@@ -6,7 +6,16 @@ export declare class ExprNumber extends ExpressionDef {
     readonly n: string;
     elementType: string;
     constructor(n: string);
-    getExpression(_fs: FieldSpace): ExprValue;
+    getExpression(fs: FieldSpace): ExprValue;
+    /**
+     * Default number type when no dialect is available.
+     * Integers default to bigint for safety, floats to float.
+     */
+    private defaultNumberType;
+    /**
+     * For constants (no dialect context), always use bigint for integers
+     * to ensure large values render correctly.
+     */
     constantExpression(): ExprValue;
     getStableLiteral(): Malloy.LiteralValue;
 }

package/dist/lang/ast/expressions/expr-number.js

@@ -31,16 +31,32 @@ class ExprNumber extends expression_def_1.ExpressionDef {
         this.n = n;
         this.elementType = 'numeric literal';
     }
-    getExpression(_fs) {
-        return this.constantExpression();
+    getExpression(fs) {
+        var _a;
+        const dialect = fs.dialectObj();
+        const dataType = (_a = dialect === null || dialect === void 0 ? void 0 : dialect.literalNumberType(this.n)) !== null && _a !== void 0 ? _a : this.defaultNumberType();
+        return (0, expr_value_1.literalExprValue)({
+            dataType,
+            value: { node: 'numberLiteral', literal: this.n },
+        });
+    }
+    /**
+     * Default number type when no dialect is available.
+     * Integers default to bigint for safety, floats to float.
+     */
+    defaultNumberType() {
+        const isInteger = /^-?\d+$/.test(this.n);
+        return isInteger
+            ? { type: 'number', numberType: 'bigint' }
+            : { type: 'number', numberType: 'float' };
     }
+    /**
+     * For constants (no dialect context), always use bigint for integers
+     * to ensure large values render correctly.
+     */
     constantExpression() {
-        const n = Number(this.n);
-        const dataType = Number.isNaN(n)
-            ? { type: 'number' }
-            : { type: 'number', numberType: Number.isInteger(n) ? 'integer' : 'float' };
         return (0, expr_value_1.literalExprValue)({
-            dataType,
+            dataType: this.defaultNumberType(),
             value: { node: 'numberLiteral', literal: this.n },
         });
     }

package/dist/lang/ast/expressions/expr-props.d.ts

@@ -63,7 +63,7 @@ export declare class ExprProps extends ExpressionDef {
     } | {
         requiresGroupBy: import("../../../model/malloy_types").RequiredGroupBy[] | undefined;
         type: "number";
-        numberType?: "integer" | "float";
+        numberType?: "integer" | "float" | "bigint";
         expressionType: import("../../../model/malloy_types").ExpressionType;
         evalSpace: import("../../../model/malloy_types").EvalSpace;
         fieldUsage: import("../../../model/malloy_types").FieldUsage[];

package/dist/lang/ast/expressions/pick-when.js

@@ -61,9 +61,16 @@ const expr_value_1 = require("../types/expr-value");
 const expression_def_1 = require("../types/expression-def");
 const malloy_element_1 = require("../types/malloy-element");
 function typeCoalesce(ev1, ev2) {
-    return ev1 === undefined || ev1.type === 'null' || ev1.type === 'error'
-        ? ev2
-        : ev1;
+    if (ev1 === undefined || ev1.type === 'null' || ev1.type === 'error') {
+        return ev2;
+    }
+    // If both are numbers but subtypes differ, strip the subtype
+    if (ev1.type === 'number' && ev2.type === 'number') {
+        if (ev1.numberType !== ev2.numberType) {
+            return { ...ev1, numberType: undefined };
+        }
+    }
+    return ev1;
 }
 class Pick extends expression_def_1.ExpressionDef {
     constructor(choices, elsePick) {

package/dist/lang/ast/types/expression-def.js

@@ -362,6 +362,40 @@ function compare(fs, left, op, right) {
         from: [lhs, rhs],
     });
 }
+/**
+ * Computes the result numberType for arithmetic operations.
+ * - Division/modulo always return float
+ * - Float wins over integer/bigint
+ * - Bigint wins over integer
+ * - Both integer = integer
+ * - Unknown = no subtype
+ */
+function mergeNumberTypes(lhs, rhs, op) {
+    // Division and modulo always return float
+    if (op === '/' || op === '%') {
+        return { type: 'number', numberType: 'float' };
+    }
+    // Only applies if both are numbers
+    if (lhs.type !== 'number' || rhs.type !== 'number') {
+        return { type: 'number' };
+    }
+    const leftSubtype = lhs.numberType;
+    const rightSubtype = rhs.numberType;
+    // If either is float, result is float
+    if (leftSubtype === 'float' || rightSubtype === 'float') {
+        return { type: 'number', numberType: 'float' };
+    }
+    // If either is bigint, result is bigint
+    if (leftSubtype === 'bigint' || rightSubtype === 'bigint') {
+        return { type: 'number', numberType: 'bigint' };
+    }
+    // Both are integer, result is integer
+    if (leftSubtype === 'integer' && rightSubtype === 'integer') {
+        return { type: 'number', numberType: 'integer' };
+    }
+    // Unknown - no subtype
+    return { type: 'number' };
+}
 function numeric(fs, left, op, right) {
     const lhs = left.getExpression(fs);
     const rhs = right.getExpression(fs);
@@ -379,7 +413,7 @@ function numeric(fs, left, op, right) {
     }
     else {
         return (0, expr_value_1.computedExprValue)({
-            dataType: { type: 'number' },
+            dataType: mergeNumberTypes(lhs, rhs, op),
             value: { node: op, kids: { left: lhs.value, right: rhs.value } },
             from: [lhs, rhs],
         });
@@ -459,7 +493,7 @@ function applyBinary(fs, left, op, right) {
                 kids: { left: num.value, right: denom.value },
             };
             return (0, expr_value_1.computedExprValue)({
-                dataType: { type: 'number' },
+                dataType: mergeNumberTypes(num, denom, op),
                 value: divmod,
                 from: [num, denom],
             });

package/dist/lang/parse-log.d.ts

@@ -385,6 +385,7 @@ type MessageParameterTypes = {
     'non-scalar-grouped-by': string;
     'missing-required-group-by': string;
     'invalid-partition-composite': string;
+    'integer-literal-out-of-range': string;
 };
 export declare const MESSAGE_FORMATTERS: PartialErrorCodeMessageMap;
 export type MessageCode = keyof MessageParameterTypes;

package/dist/lang/test/test-translator.js

@@ -133,6 +133,7 @@ function humanify(value) {
     return pretty(walk(value));
 }
 const intType = { type: 'number', numberType: 'integer' };
+const bigintType = { type: 'number', numberType: 'bigint' };
 const mockSchema = {
     'aTable': {
         type: 'table',
@@ -144,6 +145,7 @@ const mockSchema = {
             { type: 'string', name: 'astr' },
             { type: 'number', name: 'af', numberType: 'float' },
             { ...intType, name: 'ai' },
+            { ...bigintType, name: 'abig' },
             { type: 'date', name: 'ad' },
             { type: 'boolean', name: 'abool' },
             { type: 'timestamp', name: 'ats' },

package/dist/malloy.d.ts

@@ -1200,7 +1200,7 @@ declare class DataJSON extends ScalarData<string> {
 }
 declare class DataNumber extends ScalarData<number> {
     protected _field: NumberField;
-    constructor(value: number, field: NumberField, parent: DataArrayOrRecord | undefined, parentRecord: DataRecord | undefined);
+    constructor(value: unknown, field: NumberField, parent: DataArrayOrRecord | undefined, parentRecord: DataRecord | undefined);
     get field(): NumberField;
     get key(): string;
     compareTo(other: ScalarData<number>): 0 | 1 | -1;
@@ -1239,9 +1239,21 @@ export declare class DataArray extends Data<QueryData> implements Iterable<DataR
      */
     get field(): Explore;
     /**
-     * @return The raw object form of the data.
+     * @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(): QueryData;
+    /**
+     * @return Normalized data with JS native types (number | bigint, Date).
+     * Use this for CSV output, tests, and general programmatic access.
      */
     toObject(): QueryData;
+    /**
+     * @return Normalized data with JSON-safe types (numbers as number | string, dates as ISO strings).
+     * Use this for JSON serialization.
+     */
+    toJSON(): QueryData;
     path(...path: (number | string)[]): DataColumn;
     row(index: number): DataRecord;
     get rowCount(): number;
@@ -1257,7 +1269,16 @@ export declare class DataRecord extends Data<{
     readonly index: number | undefined;
     private cellCache;
     constructor(queryDataRow: QueryDataRow, index: number | undefined, field: Explore, parent: DataArrayOrRecord | undefined, parentRecord: DataRecord | undefined);
+    /**
+     * @return Normalized data with JS native types (number | bigint, Date).
+     * Use this for CSV output, tests, and general programmatic access.
+     */
     toObject(): QueryDataRow;
+    /**
+     * @return Normalized data with JSON-safe types (numbers as number | string, dates as ISO strings).
+     * Use this for JSON serialization.
+     */
+    toJSON(): QueryDataRow;
     path(...path: (number | string)[]): DataColumn;
     cell(fieldOrName: string | Field): DataColumn;
     get value(): {

package/dist/malloy.js

@@ -25,7 +25,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.InMemoryModelCache = exports.CacheManager = exports.CSVWriter = exports.JSONWriter = exports.DataWriter = exports.DataRecord = exports.DataArray = exports.Result = exports.ExploreMaterializer = exports.PreparedResultMaterializer = exports.QueryMaterializer = exports.ModelMaterializer = exports.SingleConnectionRuntime = exports.ConnectionRuntime = exports.Runtime = exports.ExploreField = exports.JoinRelationship = exports.QueryField = exports.Query = exports.StringField = exports.UnsupportedField = exports.JSONField = exports.BooleanField = exports.NumberField = exports.TimestampField = exports.DateField = exports.TimestampTimeframe = exports.DateTimeframe = exports.AtomicField = exports.AtomicFieldType = exports.Explore = exports.SourceRelationship = exports.FixedConnectionMap = exports.InMemoryURLReader = exports.EmptyURLReader = exports.PreparedResult = exports.DocumentCompletion = exports.DocumentSymbol = exports.DocumentPosition = exports.DocumentRange = exports.DocumentTablePath = exports.Parse = exports.PreparedQuery = exports.Model = exports.MalloyError = exports.Malloy = void 0;
 const lang_1 = require("./lang");
 const model_1 = require("./model");
-const luxon_1 = require("luxon");
 const dialect_1 = require("./dialect");
 const version_1 = require("./version");
 const uuid_1 = require("uuid");
@@ -33,6 +32,7 @@ const annotation_1 = require("./annotation");
 const sql_block_1 = require("./model/sql_block");
 const utils_1 = require("./lang/utils");
 const reference_list_1 = require("./lang/reference-list");
+const row_data_utils_1 = require("./api/row_data_utils");
 function isSourceComponent(source) {
     return (source.type === 'table' ||
         source.type === 'sql_select' ||
@@ -2122,7 +2122,15 @@ class ModelMaterializer extends FluentState {
         const result = await this.loadQuery(searchMapMalloy, options).run({
             rowLimit: 1000,
         });
-        return result._queryResult.result;
+        const rawResult = result._queryResult.result;
+        return rawResult.map(row => ({
+            ...row,
+            cardinality: (0, row_data_utils_1.rowDataToNumber)(row.cardinality),
+            values: row.values.map(v => ({
+                ...v,
+                weight: (0, row_data_utils_1.rowDataToNumber)(v.weight),
+            })),
+        }));
     }
     /**
      * Materialize the final query contained within this loaded `Model`.
@@ -2630,7 +2638,7 @@ class DataJSON extends ScalarData {
 }
 class DataNumber extends ScalarData {
     constructor(value, field, parent, parentRecord) {
-        super(value, field, parent, parentRecord);
+        super((0, row_data_utils_1.rowDataToNumber)(value), field, parent, parentRecord);
         this._field = field;
     }
     get field() {
@@ -2650,44 +2658,13 @@ class DataNumber extends ScalarData {
         return -1;
     }
 }
-function valueToDate(value) {
-    // TODO properly map the data from BQ/Postgres types
-    if (value instanceof Date) {
-        return value;
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const valAsAny = value;
-    if (valAsAny.constructor.name === 'Date') {
-        // For some reason duckdb TSTZ values come back as objects which do not
-        // pass "instance of" but do seem date like.
-        return new Date(value);
-    }
-    else if (typeof value === 'number') {
-        return new Date(value);
-    }
-    else if (typeof value !== 'string') {
-        return new Date(value.value);
-    }
-    else {
-        // Postgres timestamps end up here, and ideally we would know the system
-        // timezone of the postgres instance to correctly create a Date() object
-        // which represents the same instant in time, but we don't have the data
-        // flow to implement that. This may be a problem at some future day,
-        // so here is a comment, for that day.
-        let parsed = luxon_1.DateTime.fromISO(value, { zone: 'UTC' });
-        if (!parsed.isValid) {
-            parsed = luxon_1.DateTime.fromSQL(value, { zone: 'UTC' });
-        }
-        return parsed.toJSDate();
-    }
-}
 class DataTimestamp extends ScalarData {
     constructor(value, field, parent, parentRecord) {
         super(value, field, parent, parentRecord);
         this._field = field;
     }
     get value() {
-        return valueToDate(this._value);
+        return (0, row_data_utils_1.rowDataToDate)(this._value);
     }
     get field() {
         return this._field;
@@ -2711,7 +2688,7 @@ class DataDate extends ScalarData {
         this._field = field;
     }
     get value() {
-        return valueToDate(this._value);
+        return (0, row_data_utils_1.rowDataToDate)(this._value);
     }
     get field() {
         return this._field;
@@ -2755,6 +2732,161 @@ class DataNull extends Data {
         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;
+}
 class DataArray extends Data {
     constructor(queryData, field, parent, parentRecord) {
         super(field, parent, parentRecord);
@@ -2769,11 +2901,27 @@ class DataArray extends Data {
         return this._field;
     }
     /**
-     * @return The raw object form of the data.
+     * @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.
      */
-    toObject() {
+    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);
     }
@@ -2784,7 +2932,6 @@ class DataArray extends Data {
             this.rowCache.set(index, record);
         }
         return record;
-        return new DataRecord(this.queryData[index], index, this.field, this, this.parentRecord);
     }
     get rowCount() {
         return this.queryData.length;
@@ -2833,8 +2980,19 @@ class DataRecord extends Data {
         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 this.queryDataRow;
+        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);
@@ -2929,7 +3087,8 @@ class JSONWriter extends DataWriter {
             if (row.index !== undefined && row.index > 0) {
                 this.stream.write(',\n');
             }
-            const json = JSON.stringify(row.toObject(), null, 2);
+            // toJSON() returns JSON-safe values: bigints as strings, dates as ISO strings
+            const json = JSON.stringify(row.toJSON(), null, 2);
             const jsonLines = json.split('\n');
             for (let i = 0; i < jsonLines.length; i++) {
                 const line = jsonLines[i];
@@ -2991,6 +3150,10 @@ class CSVWriter extends DataWriter {
         else if (typeof value === 'boolean' || typeof value === 'number') {
             return JSON.stringify(value);
         }
+        else if (typeof value === 'bigint') {
+            // Bigints from toObject() - write as unquoted number string
+            return value.toString();
+        }
         else {
             return `${value}`;
         }