@malloydata/malloy 0.0.325 → 0.0.327

package/dist/api/core.js

@@ -89,6 +89,8 @@ function convertNumberSubtype(subtype) {
         return undefined;
     if (subtype === 'decimal')
         return 'float';
+    if (subtype === 'bigint')
+        return 'bigint';
     return 'integer';
 }
 function typeDefFromField(type) {

package/dist/api/index.d.ts

@@ -3,3 +3,4 @@ export * as stateless from './stateless';
 export * as asynchronous from './asynchronous';
 export * from './connection';
 export * as util from './util';
+export * from './row_data_utils';

package/dist/api/index.js

@@ -48,4 +48,5 @@ exports.stateless = __importStar(require("./stateless"));
 exports.asynchronous = __importStar(require("./asynchronous"));
 __exportStar(require("./connection"), exports);
 exports.util = __importStar(require("./util"));
+__exportStar(require("./row_data_utils"), exports);
 //# sourceMappingURL=index.js.map

package/dist/api/row_data_utils.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Database connections return numeric data in various forms depending on
+ * the database driver and configuration. Values may arrive as:
+ * - Native JavaScript numbers
+ * - BigInt (when jsTreatIntegerAsBigInt is enabled)
+ * - Strings (when bigNumberStrings is enabled, or for precise decimals)
+ * - Wrapper objects (e.g., Snowflake's Integer class)
+ *
+ * These utilities normalize row data into consistent JavaScript types.
+ */
+/**
+ * Converts a numeric value from database row data to a JavaScript number.
+ */
+export declare function rowDataToNumber(value: unknown): number;
+/**
+ * Converts a numeric value from database row data to a string representation.
+ * Used for bigint fields where precision must be preserved - JavaScript numbers
+ * lose precision beyond Number.MAX_SAFE_INTEGER.
+ */
+export declare function rowDataToSerializedBigint(value: unknown): string;
+/**
+ * Converts a date/timestamp value from database row data to a JavaScript Date.
+ * Database drivers return dates in various forms:
+ * - Native Date objects
+ * - Objects that look like Date but fail instanceof (DuckDB TSTZ)
+ * - Numbers (timestamps)
+ * - Objects with a .value property (some wrappers)
+ * - Strings (Postgres timestamps)
+ */
+export declare function rowDataToDate(value: unknown): Date;

package/dist/api/row_data_utils.js

@@ -0,0 +1,87 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rowDataToNumber = rowDataToNumber;
+exports.rowDataToSerializedBigint = rowDataToSerializedBigint;
+exports.rowDataToDate = rowDataToDate;
+const luxon_1 = require("luxon");
+/**
+ * Database connections return numeric data in various forms depending on
+ * the database driver and configuration. Values may arrive as:
+ * - Native JavaScript numbers
+ * - BigInt (when jsTreatIntegerAsBigInt is enabled)
+ * - Strings (when bigNumberStrings is enabled, or for precise decimals)
+ * - Wrapper objects (e.g., Snowflake's Integer class)
+ *
+ * These utilities normalize row data into consistent JavaScript types.
+ */
+/**
+ * Converts a numeric value from database row data to a JavaScript number.
+ */
+function rowDataToNumber(value) {
+    if (typeof value === 'number')
+        return value;
+    if (typeof value === 'bigint')
+        return Number(value);
+    if (typeof value === 'string')
+        return Number(value);
+    if (typeof value === 'object' && value !== null)
+        return Number(value);
+    throw new Error(`Cannot convert ${typeof value} to number: ${value}`);
+}
+/**
+ * Converts a numeric value from database row data to a string representation.
+ * Used for bigint fields where precision must be preserved - JavaScript numbers
+ * lose precision beyond Number.MAX_SAFE_INTEGER.
+ */
+function rowDataToSerializedBigint(value) {
+    if (typeof value === 'string')
+        return value;
+    if (typeof value === 'bigint')
+        return value.toString();
+    return String(value !== null && value !== void 0 ? value : '');
+}
+/**
+ * Converts a date/timestamp value from database row data to a JavaScript Date.
+ * Database drivers return dates in various forms:
+ * - Native Date objects
+ * - Objects that look like Date but fail instanceof (DuckDB TSTZ)
+ * - Numbers (timestamps)
+ * - Objects with a .value property (some wrappers)
+ * - Strings (Postgres timestamps)
+ */
+function rowDataToDate(value) {
+    var _a;
+    if (value instanceof Date) {
+        return value;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const valAsAny = value;
+    if (((_a = valAsAny === null || valAsAny === void 0 ? void 0 : valAsAny.constructor) === null || _a === void 0 ? void 0 : _a.name) === 'Date') {
+        // For some reason duckdb TSTZ values come back as objects which do not
+        // pass "instanceof" 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();
+    }
+}
+//# sourceMappingURL=row_data_utils.js.map

package/dist/api/util.js

@@ -16,7 +16,7 @@ exports.mapLogs = mapLogs;
 const malloy_tag_1 = require("@malloydata/malloy-tag");
 const annotation_1 = require("../annotation");
 const to_stable_1 = require("../to_stable");
-const luxon_1 = require("luxon");
+const row_data_utils_1 = require("./row_data_utils");
 function wrapLegacyInfoConnection(connection) {
     return {
         get dialectName() {
@@ -54,37 +54,6 @@ function wrapLegacyConnection(connection) {
         },
     };
 }
-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();
-    }
-}
 function mapData(data, schema) {
     function mapValue(value, field) {
         if (value === null) {
@@ -93,7 +62,7 @@ function mapData(data, schema) {
         else if (field.type.kind === 'date_type' ||
             field.type.kind === 'timestamp_type' ||
             field.type.kind === 'timestamptz_type') {
-            const time_value = valueToDate(value).toISOString();
+            const time_value = (0, row_data_utils_1.rowDataToDate)(value).toISOString();
             if (field.type.kind === 'date_type') {
                 return { kind: 'date_cell', date_value: time_value };
             }
@@ -102,19 +71,32 @@ function mapData(data, schema) {
             }
         }
         else if (field.type.kind === 'boolean_type') {
-            if (typeof value === 'number') {
+            if (typeof value === 'number' || typeof value === 'bigint') {
                 return { kind: 'boolean_cell', boolean_value: value !== 0 };
             }
+            if (typeof value === 'string') {
+                // MySQL with bigNumberStrings returns "0" or "1"
+                return {
+                    kind: 'boolean_cell',
+                    boolean_value: value !== '0' && value !== '',
+                };
+            }
             if (typeof value !== 'boolean') {
                 throw new Error(`Invalid boolean ${value}`);
             }
             return { kind: 'boolean_cell', boolean_value: value };
         }
         else if (field.type.kind === 'number_type') {
-            if (typeof value !== 'number') {
-                throw new Error(`Invalid number ${value}`);
+            const subtype = field.type.subtype;
+            if (subtype === 'bigint') {
+                const stringValue = (0, row_data_utils_1.rowDataToSerializedBigint)(value);
+                return { kind: 'big_number_cell', number_value: stringValue, subtype };
             }
-            return { kind: 'number_cell', number_value: value };
+            return {
+                kind: 'number_cell',
+                number_value: (0, row_data_utils_1.rowDataToNumber)(value),
+                subtype,
+            };
         }
         else if (field.type.kind === 'string_type') {
             if (typeof value !== 'string') {
@@ -221,7 +203,7 @@ function wrapResult(result) {
     }));
     return {
         schema,
-        data: mapData(result.data.toObject(), schema),
+        data: mapData(result.data.rawData, schema),
         connection_name: result.connectionName,
         annotations: annotations.length > 0 ? annotations : undefined,
         model_annotations: modelAnnotations.length > 0 ? modelAnnotations : undefined,

package/dist/connection/base_connection.js

@@ -19,19 +19,21 @@ class BaseConnection {
             try {
                 const cacheResponse = await fillCache();
                 if (typeof cacheResponse === 'string') {
-                    cached = { error: cacheResponse };
+                    // Don't cache errors - just return them
+                    return { error: cacheResponse };
                 }
                 else {
                     cached = {
                         schema: cacheResponse,
                         timestamp: refreshTimestamp !== null && refreshTimestamp !== void 0 ? refreshTimestamp : Date.now(),
                     };
+                    this.schemaCache[schemaKey] = cached;
                 }
             }
             catch (uncaught) {
-                cached = { error: uncaught.message };
+                // Don't cache errors - just return them
+                return { error: uncaught.message };
             }
-            this.schemaCache[schemaKey] = cached;
         }
         if (cached.error) {
             return cached;

package/dist/dialect/dialect.d.ts

@@ -7,6 +7,14 @@ interface DialectField {
     sqlOutputName: string;
 }
 export type DialectFieldList = DialectField[];
+export declare const MIN_INT32 = -2147483648;
+export declare const MAX_INT32 = 2147483647;
+export declare const MIN_INT64: bigint;
+export declare const MAX_INT64: bigint;
+export declare const MIN_INT128: bigint;
+export declare const MAX_INT128: bigint;
+export declare const MIN_DECIMAL38: bigint;
+export declare const MAX_DECIMAL38: bigint;
 /**
  * Data which dialect methods need in order to correctly generate SQL.
  * Initially this is just timezone related, but I made this an interface
@@ -25,6 +33,28 @@ export declare function qtz(qi: QueryInfo): string | undefined;
 export type OrderByClauseType = 'output_name' | 'ordinal' | 'expression';
 export type OrderByRequest = 'query' | 'turtle' | 'analytical';
 export type BooleanTypeSupport = 'supported' | 'simulated' | 'none';
+/**
+ * Min/max range for an integer type.
+ * - null: type is not supported by this dialect
+ * - {min, max}: the range of values (use the exported constants like MIN_INT64, MAX_INT64)
+ */
+export type IntegerTypeRange = {
+    min: number | bigint;
+    max: number | bigint;
+} | null;
+/**
+ * Configuration for integer literal type selection.
+ *
+ * When translating an integer literal, the translator walks down this list
+ * (integer → bigint) and selects the first type that can hold the value.
+ * If no type can hold the value (or all are null), an error is raised.
+ */
+export interface IntegerTypeLimits {
+    /** Range for 'integer' type (-2^53 to 2^53-1, safe for JS Number) */
+    integer: IntegerTypeRange;
+    /** Range for 'bigint' type (64-bit or larger integers, varies by dialect) */
+    bigint: IntegerTypeRange;
+}
 export declare abstract class Dialect {
     abstract name: string;
     abstract defaultNumberType: string;
@@ -51,6 +81,7 @@ export declare abstract class Dialect {
     orderByClause: OrderByClauseType;
     nullMatchesFunctionSignature: boolean;
     supportsSelectReplace: boolean;
+    supportsBigIntPrecision: boolean;
     supportsComplexFilteredSources: boolean;
     supportsTempTables: boolean;
     hasModOperator: boolean;
@@ -62,6 +93,11 @@ export declare abstract class Dialect {
     compoundObjectInSchema: boolean;
     booleanType: BooleanTypeSupport;
     likeEscape: boolean;
+    /**
+     * Ranges for integer types in this dialect.
+     * Default supports integer (JS safe) and bigint (64-bit signed).
+     */
+    integerTypeLimits: IntegerTypeLimits;
     /**
      * Create the appropriate time literal IR node based on dialect support.
      * Static method so it can be called with undefined dialect (e.g., ConstantFieldSpace).

package/dist/dialect/dialect.js

@@ -22,10 +22,26 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Dialect = exports.dayIndex = void 0;
+exports.Dialect = exports.dayIndex = exports.MAX_DECIMAL38 = exports.MIN_DECIMAL38 = exports.MAX_INT128 = exports.MIN_INT128 = exports.MAX_INT64 = exports.MIN_INT64 = exports.MAX_INT32 = exports.MIN_INT32 = void 0;
 exports.inDays = inDays;
 exports.qtz = qtz;
 const malloy_types_1 = require("../model/malloy_types");
+/*
+ * Standard integer type limits.
+ * Use these in dialect integerTypeLimits definitions.
+ */
+// 32-bit signed integer limits (for databases with 32-bit INTEGER type)
+exports.MIN_INT32 = -2147483648; // -2^31
+exports.MAX_INT32 = 2147483647; // 2^31 - 1
+// 64-bit signed integer limits
+exports.MIN_INT64 = BigInt('-9223372036854775808'); // -2^63
+exports.MAX_INT64 = BigInt('9223372036854775807'); // 2^63 - 1
+// 128-bit signed integer limits (for DuckDB HUGEINT)
+exports.MIN_INT128 = BigInt('-170141183460469231731687303715884105728'); // -2^127
+exports.MAX_INT128 = BigInt('170141183460469231731687303715884105727'); // 2^127 - 1
+// Decimal(38,0) limits (for Snowflake NUMBER(38,0))
+exports.MIN_DECIMAL38 = BigInt('-99999999999999999999999999999999999999'); // -(10^38 - 1)
+exports.MAX_DECIMAL38 = BigInt('99999999999999999999999999999999999999'); // 10^38 - 1
 const allUnits = [
     'microsecond',
     'millisecond',
@@ -72,6 +88,9 @@ class Dialect {
         this.nullMatchesFunctionSignature = true;
         // support select * replace(...)
         this.supportsSelectReplace = true;
+        // Does the data path preserve bigint precision? False for dialects that
+        // serialize results through JSON (postgres, presto, trino)
+        this.supportsBigIntPrecision = true;
         // ability to join source with a filter on a joined source.
         this.supportsComplexFilteredSources = true;
         // can create temp tables
@@ -90,6 +109,14 @@ class Dialect {
         this.booleanType = 'supported';
         // Like characters are escaped with ESCAPE clause
         this.likeEscape = true;
+        /**
+         * Ranges for integer types in this dialect.
+         * Default supports integer (JS safe) and bigint (64-bit signed).
+         */
+        this.integerTypeLimits = {
+            integer: { min: Number.MIN_SAFE_INTEGER, max: Number.MAX_SAFE_INTEGER },
+            bigint: { min: exports.MIN_INT64, max: exports.MAX_INT64 },
+        };
     }
     /**
      * Create the appropriate time literal IR node based on dialect support.

package/dist/dialect/duckdb/duckdb.d.ts

@@ -1,6 +1,6 @@
 import type { Sampling, AtomicTypeDef, RegexMatchExpr, MeasureTimeExpr, BasicAtomicTypeDef, RecordLiteralNode, OrderBy, TimestampUnit } from '../../model/malloy_types';
 import type { DialectFunctionOverloadDef } from '../functions';
-import type { DialectFieldList, FieldReferenceType } from '../dialect';
+import type { DialectFieldList, FieldReferenceType, IntegerTypeLimits } from '../dialect';
 import { PostgresBase } from '../pg_impl';
 export declare class DuckDBDialect extends PostgresBase {
     name: string;
@@ -22,6 +22,7 @@ export declare class DuckDBDialect extends PostgresBase {
     supportsSafeCast: boolean;
     supportsNesting: boolean;
     supportsCountApprox: boolean;
+    integerTypeLimits: IntegerTypeLimits;
     get udfPrefix(): string;
     quoteTablePath(tableName: string): string;
     sqlGroupSetTable(groupSetCount: number): string;

package/dist/dialect/duckdb/duckdb.js

@@ -34,15 +34,16 @@ const tiny_parser_1 = require("../tiny_parser");
 // need to refactor runSQL to take a SQLBlock instead of just a sql string.
 const hackSplitComment = '-- hack: split on this';
 const duckDBToMalloyTypes = {
-    'BIGINT': { type: 'number', numberType: 'integer' },
+    'BIGINT': { type: 'number', numberType: 'bigint' },
     'INTEGER': { type: 'number', numberType: 'integer' },
     'TINYINT': { type: 'number', numberType: 'integer' },
     'SMALLINT': { type: 'number', numberType: 'integer' },
-    'UBIGINT': { type: 'number', numberType: 'integer' },
+    'UBIGINT': { type: 'number', numberType: 'bigint' },
     'UINTEGER': { type: 'number', numberType: 'integer' },
     'UTINYINT': { type: 'number', numberType: 'integer' },
     'USMALLINT': { type: 'number', numberType: 'integer' },
-    'HUGEINT': { type: 'number', numberType: 'integer' },
+    'HUGEINT': { type: 'number', numberType: 'bigint' },
+    'UHUGEINT': { type: 'number', numberType: 'bigint' },
     'DOUBLE': { type: 'number', numberType: 'float' },
     'FLOAT': { type: 'number', numberType: 'float' },
     'VARCHAR': { type: 'string' },
@@ -72,6 +73,11 @@ class DuckDBDialect extends pg_impl_1.PostgresBase {
         this.supportsSafeCast = true;
         this.supportsNesting = true;
         this.supportsCountApprox = true;
+        // DuckDB supports HUGEINT (128-bit signed integer)
+        this.integerTypeLimits = {
+            integer: { min: dialect_1.MIN_INT32, max: dialect_1.MAX_INT32 },
+            bigint: { min: dialect_1.MIN_INT128, max: dialect_1.MAX_INT128 },
+        };
     }
     // hack until they support temporary macros.
     get udfPrefix() {
@@ -275,6 +281,9 @@ class DuckDBDialect extends pg_impl_1.PostgresBase {
             if (malloyType.numberType === 'integer') {
                 return 'integer';
             }
+            else if (malloyType.numberType === 'bigint') {
+                return 'hugeint';
+            }
             else {
                 return 'double precision';
             }

package/dist/dialect/mysql/mysql.js

@@ -46,12 +46,12 @@ const mysqlToMalloyTypes = {
     'smallint': { type: 'number', numberType: 'integer' },
     'mediumint': { type: 'number', numberType: 'integer' },
     'int': { type: 'number', numberType: 'integer' },
-    'bigint': { type: 'number', numberType: 'integer' },
+    'bigint': { type: 'number', numberType: 'bigint' },
     'tinyint unsigned': { type: 'number', numberType: 'integer' },
     'smallint unsigned': { type: 'number', numberType: 'integer' },
     'mediumint unsigned': { type: 'number', numberType: 'integer' },
     'int unsigned': { type: 'number', numberType: 'integer' },
-    'bigint unsigned': { type: 'number', numberType: 'integer' },
+    'bigint unsigned': { type: 'number', numberType: 'bigint' },
     'double': { type: 'number', numberType: 'float' },
     'varchar': { type: 'string' },
     'varbinary': { type: 'string' },
@@ -68,7 +68,15 @@ const mysqlToMalloyTypes = {
 function malloyTypeToJSONTableType(malloyType) {
     switch (malloyType.type) {
         case 'number':
-            return malloyType.numberType === 'integer' ? 'INT' : 'DOUBLE';
+            if (malloyType.numberType === 'integer') {
+                return 'INT';
+            }
+            else if (malloyType.numberType === 'bigint') {
+                return 'BIGINT';
+            }
+            else {
+                return 'DOUBLE';
+            }
         case 'string':
             return 'CHAR(255)'; // JSON_TABLE needs a length
         case 'boolean':
@@ -116,7 +124,13 @@ class MySQLDialect extends dialect_1.Dialect {
     malloyTypeToSQLType(malloyType) {
         switch (malloyType.type) {
             case 'number':
-                return malloyType.numberType === 'integer' ? 'SIGNED' : 'DOUBLE';
+                if (malloyType.numberType === 'integer' ||
+                    malloyType.numberType === 'bigint') {
+                    return 'SIGNED';
+                }
+                else {
+                    return 'DOUBLE';
+                }
             case 'string':
                 return 'CHAR';
             case 'boolean':

package/dist/dialect/pg_impl.d.ts

@@ -8,6 +8,7 @@ export declare const timeExtractMap: Record<string, string>;
  */
 export declare abstract class PostgresBase extends Dialect {
     hasTimestamptz: boolean;
+    supportsBigIntPrecision: boolean;
     sqlNowExpr(): string;
     sqlTimeExtractExpr(qi: QueryInfo, from: TimeExtractExpr): string;
     sqlCast(qi: QueryInfo, cast: TypecastExpr): string;

package/dist/dialect/pg_impl.js

@@ -21,6 +21,8 @@ class PostgresBase extends dialect_1.Dialect {
     constructor() {
         super(...arguments);
         this.hasTimestamptz = true;
+        // Postgres-family dialects use JSON serialization which loses bigint precision
+        this.supportsBigIntPrecision = false;
     }
     sqlNowExpr() {
         return 'LOCALTIMESTAMP';

package/dist/dialect/postgres/postgres.js

@@ -53,7 +53,7 @@ const postgresToMalloyTypes = {
     'text': { type: 'string' },
     'date': { type: 'date' },
     'integer': { type: 'number', numberType: 'integer' },
-    'bigint': { type: 'number', numberType: 'integer' },
+    'bigint': { type: 'number', numberType: 'bigint' },
     'double precision': { type: 'number', numberType: 'float' },
     'timestamp without time zone': { type: 'timestamp' },
     'timestamp with time zone': { type: 'timestamptz' },
@@ -321,6 +321,9 @@ class PostgresDialect extends pg_impl_1.PostgresBase {
             if (malloyType.numberType === 'integer') {
                 return 'integer';
             }
+            else if (malloyType.numberType === 'bigint') {
+                return 'bigint';
+            }
             else {
                 return 'double precision';
             }

package/dist/dialect/snowflake/snowflake.d.ts

@@ -1,6 +1,6 @@
 import type { Sampling, AtomicTypeDef, TimeExtractExpr, TypecastExpr, MeasureTimeExpr, RegexMatchExpr, BasicAtomicTypeDef, TimestampTypeDef, ArrayLiteralNode, RecordLiteralNode } from '../../model/malloy_types';
 import type { DialectFunctionOverloadDef } from '../functions';
-import type { DialectFieldList, FieldReferenceType, QueryInfo } from '../dialect';
+import type { DialectFieldList, FieldReferenceType, IntegerTypeLimits, QueryInfo } from '../dialect';
 import { Dialect } from '../dialect';
 export declare class SnowflakeDialect extends Dialect {
     name: string;
@@ -26,6 +26,7 @@ export declare class SnowflakeDialect extends Dialect {
     supportsQualify: boolean;
     supportsPipelinesInViews: boolean;
     supportsComplexFilteredSources: boolean;
+    integerTypeLimits: IntegerTypeLimits;
     quoteTablePath(tablePath: string): string;
     sqlGroupSetTable(groupSetCount: number): string;
     sqlAnyValue(groupSet: number, fieldName: string): string;

package/dist/dialect/snowflake/snowflake.js

@@ -45,17 +45,15 @@ const snowflakeToMalloyTypes = {
     'nvarchar2': { type: 'string' },
     'char varying': { type: 'string' },
     'nchar varying': { type: 'string' },
-    // numbers
-    'number': { type: 'number', numberType: 'integer' },
-    'numeric': { type: 'number', numberType: 'integer' },
-    'decimal': { type: 'number', numberType: 'integer' },
-    'dec': { type: 'number', numberType: 'integer' },
-    'integer': { type: 'number', numberType: 'integer' },
-    'int': { type: 'number', numberType: 'integer' },
-    'bigint': { type: 'number', numberType: 'integer' },
-    'smallint': { type: 'number', numberType: 'integer' },
-    'tinyint': { type: 'number', numberType: 'integer' },
-    'byteint': { type: 'number', numberType: 'integer' },
+    // numbers - Snowflake uses NUMBER(38,0) for all integers, which exceeds 64-bit
+    // NUMBER, NUMERIC, DECIMAL, DEC are handled dynamically in sqlTypeToMalloyType
+    // because they can be integers or floats depending on scale.
+    'integer': { type: 'number', numberType: 'bigint' },
+    'int': { type: 'number', numberType: 'bigint' },
+    'bigint': { type: 'number', numberType: 'bigint' },
+    'smallint': { type: 'number', numberType: 'bigint' },
+    'tinyint': { type: 'number', numberType: 'bigint' },
+    'byteint': { type: 'number', numberType: 'bigint' },
     'float': { type: 'number', numberType: 'float' },
     'float4': { type: 'number', numberType: 'float' },
     'float8': { type: 'number', numberType: 'float' },
@@ -100,6 +98,11 @@ class SnowflakeDialect extends dialect_1.Dialect {
         this.supportsQualify = false;
         this.supportsPipelinesInViews = false;
         this.supportsComplexFilteredSources = false;
+        // Snowflake uses NUMBER(38,0) for all integers - only one integer type
+        this.integerTypeLimits = {
+            integer: { min: dialect_1.MIN_DECIMAL38, max: dialect_1.MAX_DECIMAL38 },
+            bigint: null,
+        };
     }
     // don't mess with the table pathing.
     quoteTablePath(tablePath) {
@@ -434,8 +437,9 @@ ${(0, utils_1.indent)(sql)}
             return 'VARCHAR';
         }
         else if (malloyType.type === 'number') {
-            if (malloyType.numberType === 'integer') {
-                return 'INTEGER';
+            if (malloyType.numberType === 'integer' ||
+                malloyType.numberType === 'bigint') {
+                return 'NUMBER';
             }
             else {
                 return 'DOUBLE';
@@ -468,10 +472,28 @@ ${(0, utils_1.indent)(sql)}
         var _a, _b;
         // Remove trailing params
         const baseSqlType = (_b = (_a = sqlType.match(/^([\w\s]+)/)) === null || _a === void 0 ? void 0 : _a.at(0)) !== null && _b !== void 0 ? _b : sqlType;
-        return (snowflakeToMalloyTypes[baseSqlType.trim().toLowerCase()] || {
+        const lowerType = baseSqlType.trim().toLowerCase();
+        const mapped = snowflakeToMalloyTypes[lowerType];
+        if (mapped) {
+            return mapped;
+        }
+        // Handle NUMBER/NUMERIC/DECIMAL with scale
+        // If scale > 0, it's a float (decimal). If scale == 0 or omitted, it's a bigint (integer).
+        if (['number', 'numeric', 'decimal', 'dec'].includes(lowerType)) {
+            const match = sqlType.match(/\(\s*\d+\s*,\s*(\d+)\s*\)/);
+            if (match) {
+                const scale = parseInt(match[1], 10);
+                if (scale > 0) {
+                    return { type: 'number', numberType: 'float' };
+                }
+            }
+            // Default to bigint if scale is 0 or not specified (Snowflake defaults to NUMBER(38,0))
+            return { type: 'number', numberType: 'bigint' };
+        }
+        return {
             type: 'sql native',
             rawType: sqlType,
-        });
+        };
     }
     castToString(expression) {
         return `TO_VARCHAR(${expression})`;

package/dist/dialect/standardsql/standardsql.d.ts

@@ -1,6 +1,6 @@
 import type { Sampling, AtomicTypeDef, TimeExtractExpr, TypecastExpr, RegexMatchExpr, MeasureTimeExpr, BasicAtomicTypeDef, RecordLiteralNode, ArrayLiteralNode, TimestampUnit, TimestampTypeDef } from '../../model/malloy_types';
 import type { DialectFunctionOverloadDef } from '../functions';
-import type { DialectFieldList, OrderByRequest, QueryInfo } from '../dialect';
+import type { DialectFieldList, IntegerTypeLimits, OrderByRequest, QueryInfo } from '../dialect';
 import { Dialect } from '../dialect';
 export declare class StandardSQLDialect extends Dialect {
     name: string;
@@ -27,6 +27,7 @@ export declare class StandardSQLDialect extends Dialect {
     nestedArrays: boolean;
     supportsHyperLogLog: boolean;
     likeEscape: boolean;
+    integerTypeLimits: IntegerTypeLimits;
     quoteTablePath(tablePath: string): string;
     needsCivilTimeComputation(typeDef: AtomicTypeDef, truncateTo: TimestampUnit | undefined, offsetUnit: TimestampUnit | undefined, qi: QueryInfo): {
         needed: boolean;