@malloydata/db-snowflake 0.0.375 → 0.0.377

package/dist/index.js

@@ -30,7 +30,7 @@ const snowflake_connection_2 = require("./snowflake_connection");
 (0, malloy_1.registerConnectionType)('snowflake', {
     displayName: 'Snowflake',
     factory: async (config) => {
-        const { name, is: _, setupSQL, timeoutMs, schemaSampleTimeoutMs, ...props } = config;
+        const { name, is: _, setupSQL, timeoutMs, schemaSampleTimeoutMs, schemaSampleRowLimit, schemaSampleFullScanMaxBytes, ...props } = config;
         // ConnectionConfig values are trusted to match ConnectionOptions fields
         // because the property definitions below declare matching names/types.
         // The double cast bridges Malloy's generic config to snowflake-sdk's
@@ -50,6 +50,16 @@ const snowflake_connection_2 = require("./snowflake_connection");
                 : typeof schemaSampleTimeoutMs === 'string'
                     ? parseInt(schemaSampleTimeoutMs, 10)
                     : undefined,
+            schemaSampleRowLimit: typeof schemaSampleRowLimit === 'number'
+                ? schemaSampleRowLimit
+                : typeof schemaSampleRowLimit === 'string'
+                    ? parseInt(schemaSampleRowLimit, 10)
+                    : undefined,
+            schemaSampleFullScanMaxBytes: typeof schemaSampleFullScanMaxBytes === 'number'
+                ? schemaSampleFullScanMaxBytes
+                : typeof schemaSampleFullScanMaxBytes === 'string'
+                    ? parseInt(schemaSampleFullScanMaxBytes, 10)
+                    : undefined,
         });
     },
     properties: [
@@ -91,13 +101,30 @@ const snowflake_connection_2 = require("./snowflake_connection");
             displayName: 'Timeout (ms)',
             type: 'number',
             optional: true,
+            default: 600000,
         },
         {
             name: 'schemaSampleTimeoutMs',
             displayName: 'Schema Sample Timeout (ms)',
             type: 'number',
             optional: true,
-            description: 'Timeout for the query that samples variant columns to detect their schema (default 15000)',
+            default: 15000,
+            description: 'Timeout for the query that samples variant columns to detect their schema.',
+        },
+        {
+            name: 'schemaSampleRowLimit',
+            displayName: 'Schema Sample Row Limit',
+            type: 'number',
+            optional: true,
+            default: 1000,
+            description: 'Row limit for the variant schema sample. Ignored for tables small enough to full-scan.',
+        },
+        {
+            name: 'schemaSampleFullScanMaxBytes',
+            displayName: 'Schema Full-Scan Max Bytes',
+            type: 'number',
+            optional: true,
+            description: 'Tables with BYTES at or below this value are full-scanned during variant schema inference instead of sampled. When unset, the connection uses an internal threshold; picking a value here is a policy choice tied to the size-probe behavior.',
         },
         {
             name: 'setupSQL',

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/snowflake_connection.d.ts

@@ -1,5 +1,4 @@
 import type { RunSQLOptions, MalloyQueryData, QueryRunStats, Connection, PersistSQLResults, StreamingConnection, PooledConnection, SQLSourceDef, TableSourceDef, QueryRecord, TestableConnection, SQLSourceRequest } from '@malloydata/malloy';
-import { TinyParser } from '@malloydata/malloy';
 import { BaseConnection } from '@malloydata/malloy/connection';
 import type { ConnectionOptions } from 'snowflake-sdk';
 import type { Options as PoolOptions } from 'generic-pool';
@@ -7,6 +6,36 @@ type namespace = {
     database: string;
     schema: string;
 };
+/**
+ * Output of the INFORMATION_SCHEMA.TABLES probe. Undefined when the
+ * probe didn't run (non-parseable name) or couldn't find numeric size
+ * info (views, missing permissions).
+ */
+export interface TableSizeProbe {
+    bytes: number;
+    rowCount: number;
+}
+/**
+ * Three-way tier that drives variant schema sampling. Extracted as a
+ * pure function so cost-policy decisions are unit-testable.
+ *
+ *   full-scan-then-sample: probe confirmed a small base table. One
+ *     full scan catches rare fields. On failure, fall through to the
+ *     sample chain rather than accept opaque variant.
+ *
+ *   tablesample-only: probe confirmed a base table above the small
+ *     threshold. TABLESAMPLE BLOCK is safe (reads a few micro
+ *     partitions). Plain LIMIT without a WHERE is unsafe on large
+ *     partitioned tables, so we skip the LIMIT fallback — we'd rather
+ *     degrade to variant than issue a runaway query.
+ *
+ *   tablesample-then-limit: probe gave no size info (views, temp
+ *     views, exotic names). We can't distinguish a small view from a
+ *     view over a petabyte table, so we do best-effort sampling. This
+ *     is the acknowledged "can't help you" case from the design doc.
+ */
+export type SampleStrategy = 'full-scan-then-sample' | 'tablesample-only' | 'tablesample-then-limit';
+export declare function pickSampleStrategy(probe: TableSizeProbe | undefined, fullScanMaxBytes: number): SampleStrategy;
 export interface SnowflakeConnectionOptions {
     connOptions?: ConnectionOptions;
     poolOptions?: PoolOptions;
@@ -14,15 +43,10 @@ export interface SnowflakeConnectionOptions {
     queryOptions?: RunSQLOptions;
     timeoutMs?: number;
     schemaSampleTimeoutMs?: number;
+    schemaSampleRowLimit?: number;
+    schemaSampleFullScanMaxBytes?: number;
     setupSQL?: string;
 }
-type PathChain = {
-    arrayRef: true;
-    next?: PathChain;
-} | {
-    name: string;
-    next?: PathChain;
-};
 export declare class SnowflakeConnection extends BaseConnection implements Connection, PooledConnection, PersistSQLResults, StreamingConnection, TestableConnection {
     readonly name: string;
     private readonly dialect;
@@ -32,6 +56,8 @@ export declare class SnowflakeConnection extends BaseConnection implements Conne
     private queryOptions;
     private timeoutMs;
     private schemaSampleTimeoutMs;
+    private schemaSampleRowLimit;
+    private schemaSampleFullScanMaxBytes;
     private setupSQL;
     constructor(name: string, options?: SnowflakeConnectionOptions);
     get dialectName(): string;
@@ -48,6 +74,20 @@ export declare class SnowflakeConnection extends BaseConnection implements Conne
     runSQLStream(sqlCommand: string, options?: RunSQLOptions): AsyncIterableIterator<QueryRecord>;
     test(): Promise<void>;
     private schemaFromTablePath;
+    /**
+     * Cheap metadata probe: ask INFORMATION_SCHEMA.TABLES for the row count
+     * and byte size of tablePath. Returns undefined when the name doesn't
+     * parse as a two- or three-part identifier, when the probe query fails,
+     * or when the row has no numeric BYTES (views and external tables
+     * typically report NULL).
+     *
+     * Two-part `schema.table` names use the current database's
+     * INFORMATION_SCHEMA; three-part `db.schema.table` names address
+     * INFORMATION_SCHEMA in the named database. Identifiers are parsed
+     * with Snowflake's quoting rules so bare parts case-fold to upper and
+     * quoted parts are compared verbatim against the catalog.
+     */
+    private probeTableSize;
     /**
      * Try to run a schema sampling query, with fallback.
      * First tries the primary query (e.g. using TABLESAMPLE for speed).
@@ -64,9 +104,4 @@ export declare class SnowflakeConnection extends BaseConnection implements Conne
     fetchSelectSchema(sqlRef: SQLSourceRequest): Promise<SQLSourceDef>;
     manifestTemporaryTable(sqlCommand: string): Promise<string>;
 }
-export declare class PathParser extends TinyParser {
-    constructor(pathName: string);
-    getName(): string;
-    pathChain(): PathChain;
-}
 export {};

package/dist/snowflake_connection.js

@@ -22,131 +22,19 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PathParser = exports.SnowflakeConnection = void 0;
+exports.SnowflakeConnection = void 0;
+exports.pickSampleStrategy = pickSampleStrategy;
 const malloy_1 = require("@malloydata/malloy");
 const connection_1 = require("@malloydata/malloy/connection");
 const snowflake_executor_1 = require("./snowflake_executor");
-class SnowField {
-    constructor(name, type, dialect) {
-        this.name = name;
-        this.type = type;
-        this.dialect = dialect;
-    }
-    fieldDef() {
-        return {
-            ...this.dialect.sqlTypeToMalloyType(this.type),
-            name: this.name,
-        };
-    }
-    walk(_path, _fieldType) {
-        throw new Error('SNOWWFLAKE SCHEMA PARSE ERROR: Should not walk through fields');
-    }
-    static make(name, fieldType, d) {
-        if (fieldType === 'array') {
-            return new SnowArray(name, d);
-        }
-        else if (fieldType === 'object') {
-            return new SnowObject(name, d);
-        }
-        return new SnowField(name, fieldType, d);
-    }
-}
-class SnowObject extends SnowField {
-    constructor(name, d) {
-        super(name, 'object', d);
-        this.fieldMap = new Map();
-    }
-    get fields() {
-        const fields = [];
-        for (const [_, fieldObj] of this.fieldMap) {
-            fields.push(fieldObj.fieldDef());
-        }
-        return fields;
-    }
-    fieldDef() {
-        const rec = {
-            type: 'record',
-            name: this.name,
-            fields: this.fields,
-            join: 'one',
-        };
-        return rec;
-    }
-    walk(path, fieldType) {
-        if ('name' in path) {
-            const field = this.fieldMap.get(path.name);
-            if (path.next) {
-                if (field instanceof SnowObject || field instanceof SnowArray) {
-                    field.walk(path.next, fieldType);
-                    return;
-                }
-                // Field is missing or is a scalar leaf — the variant data has
-                // inconsistent structure across rows. Degrade to opaque variant.
-                this.fieldMap.set(path.name, new SnowField(path.name, 'variant', this.dialect));
-                return;
-            }
-            else {
-                if (!field) {
-                    this.fieldMap.set(path.name, SnowField.make(path.name, fieldType, this.dialect));
-                    return;
-                }
-            }
-            return;
-        }
-        // Array reference in an object context — inconsistent structure.
-        // Ignore this path; the object keeps whatever fields it already has.
-    }
-}
-class SnowArray extends SnowField {
-    constructor(name, d) {
-        super(name, 'array', d);
-        this.arrayOf = 'unknown';
-    }
-    isArrayOf(type) {
-        if (this.arrayOf !== 'unknown') {
-            this.arrayOf = 'variant';
-            return;
-        }
-        this.arrayOf = type;
-        if (type === 'object') {
-            this.objectChild = new SnowObject('', this.dialect);
-        }
-        else if (type === 'array') {
-            this.arrayChild = new SnowArray('', this.dialect);
-        }
-    }
-    fieldDef() {
-        if (this.objectChild) {
-            const t = (0, malloy_1.mkArrayDef)({ type: 'record', fields: this.objectChild.fields }, this.name);
-            return t;
-        }
-        if (this.arrayChild) {
-            return (0, malloy_1.mkArrayDef)(this.arrayChild.fieldDef(), this.name);
-        }
-        return (0, malloy_1.mkArrayDef)(this.dialect.sqlTypeToMalloyType(this.arrayOf), this.name);
-    }
-    walk(path, fieldType) {
-        if ('arrayRef' in path) {
-            if (path.next) {
-                const next = this.arrayChild || this.objectChild;
-                if (next) {
-                    next.walk(path.next, fieldType);
-                    return;
-                }
-                // Array elements were scalars but now we see deeper structure —
-                // inconsistent variant data. Degrade to variant array.
-                this.arrayOf = 'variant';
-                return;
-            }
-            else {
-                this.isArrayOf(fieldType);
-                return;
-            }
-        }
-        // Name reference in an array context — inconsistent structure.
-        // Degrade to variant array.
-        this.arrayOf = 'variant';
-    }
+const snowflake_variant_schema_1 = require("./snowflake_variant_schema");
+const snowflake_table_name_1 = require("./snowflake_table_name");
+function pickSampleStrategy(probe, fullScanMaxBytes) {
+    if (probe === undefined)
+        return 'tablesample-then-limit';
+    if (probe.bytes <= fullScanMaxBytes)
+        return 'full-scan-then-sample';
+    return 'tablesample-only';
 }
 /**
  * Default statement timeoutMs value, 10 Mins
@@ -154,7 +42,7 @@ class SnowArray extends SnowField {
 const TIMEOUT_MS = 1000 * 60 * 10;
 class SnowflakeConnection extends connection_1.BaseConnection {
     constructor(name, options) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e;
         super();
         this.name = name;
         this.dialect = new malloy_1.SnowflakeDialect();
@@ -170,6 +58,9 @@ class SnowflakeConnection extends connection_1.BaseConnection {
         this.queryOptions = (_a = options === null || options === void 0 ? void 0 : options.queryOptions) !== null && _a !== void 0 ? _a : {};
         this.timeoutMs = (_b = options === null || options === void 0 ? void 0 : options.timeoutMs) !== null && _b !== void 0 ? _b : TIMEOUT_MS;
         this.schemaSampleTimeoutMs = (_c = options === null || options === void 0 ? void 0 : options.schemaSampleTimeoutMs) !== null && _c !== void 0 ? _c : 15000;
+        this.schemaSampleRowLimit = (_d = options === null || options === void 0 ? void 0 : options.schemaSampleRowLimit) !== null && _d !== void 0 ? _d : 1000;
+        this.schemaSampleFullScanMaxBytes =
+            (_e = options === null || options === void 0 ? void 0 : options.schemaSampleFullScanMaxBytes) !== null && _e !== void 0 ? _e : 100000000;
     }
     get dialectName() {
         return 'snowflake';
@@ -228,18 +119,20 @@ class SnowflakeConnection extends connection_1.BaseConnection {
         await this.executor.batch('SELECT 1 as one');
     }
     async schemaFromTablePath(tablePath, structDef) {
-        var _a, _b;
+        var _a, _b, _c, _d;
         const infoQuery = `DESCRIBE TABLE ${tablePath}`;
         const rows = await this.executor.batch(infoQuery);
-        const variants = [];
+        const nestedColumns = [];
         const notVariant = new Map();
         for (const row of rows) {
             // data types look like `VARCHAR(1234)` or `NUMBER(10,2)`
             const fullType = row['type'].toLocaleLowerCase();
             const baseType = fullType.split('(')[0];
             const name = row['name'];
-            if (['variant', 'array', 'object'].includes(baseType)) {
-                variants.push(name);
+            if (baseType === 'variant' ||
+                baseType === 'array' ||
+                baseType === 'object') {
+                nestedColumns.push({ kind: baseType, name });
             }
             else {
                 notVariant.set(name, true);
@@ -253,69 +146,144 @@ class SnowflakeConnection extends connection_1.BaseConnection {
             }
         }
         // VARIANT, ARRAY, and OBJECT columns don't have schema in metadata —
-        // we have to sample actual data and inspect it to discover the structure.
-        // This is inherently heuristic (we only look at 100 rows) and can be
-        // slow on large partitioned tables or expensive views.
-        if (variants.length > 0) {
-            const variantArgs = variants.map(v => `'${v}', "${v}"`).join(', ');
-            // Build the analysis query that flattens sampled rows and detects
-            // the type of each leaf path. We only construct from variant columns
-            // (not *) to avoid flattening the entire row on wide tables.
-            // Paths with multiple types across the sample are dropped (HAVING
-            // count(*) <= 1), and nulls are ignored.
+        // we have to sample actual data and inspect it to discover the
+        // structure. Cost control happens in two places:
+        //   1. project only the nested columns (via object_construct), so
+        //      bytes-on-wire are bounded by actual variant content.
+        //   2. tier the sampling strategy by probeTableSize (see
+        //      pickSampleStrategy) — small base tables get a full scan;
+        //      large base tables get TABLESAMPLE only (no unsafe LIMIT
+        //      fallback); unknown-size sources (views, temp views) get
+        //      the best-effort TABLESAMPLE→LIMIT chain.
+        if (nestedColumns.length > 0) {
+            const variantArgs = nestedColumns
+                .map(v => `'${v.name}', "${v.name}"`)
+                .join(', ');
+            // Flatten sampled rows and emit each distinct (path, type) pair.
+            // Conflicting pairs at the same path flow through to mergeShape,
+            // which collapses them to variant — that is how we honestly
+            // surface mixed-type fields to the user.
             const makeSampleQuery = (sampleClause) => `
-        select path, min(type) as type
-        from (
-          select
-            regexp_replace(path, '\\\\[[0-9]+\\\\]', '[*]') as path,
-            case
-              when typeof(value) = 'INTEGER' then 'decimal'
-              when typeof(value) = 'DOUBLE' then 'decimal'
-            else lower(typeof(value)) end as type
-          from
-            (${sampleClause})
-              ,table(flatten(input => o, recursive => true)) as meta
-          group by 1,2
-        )
-        where type != 'null_value'
-        group BY 1
-        having count(*) <=1
-        order by path;
+        select
+          regexp_replace(path, '\\\\[[0-9]+\\\\]', '[*]') as path,
+          case
+            when typeof(value) = 'INTEGER' then 'decimal'
+            when typeof(value) = 'DOUBLE' then 'decimal'
+          else lower(typeof(value)) end as type
+        from
+          (${sampleClause})
+            ,table(flatten(input => o, recursive => true)) as meta
+        where typeof(value) != 'NULL_VALUE'
+        group by 1, 2
+        order by 1;
       `;
-            const limitClause = `select object_construct(${variantArgs}) o` +
-                ` from ${tablePath} limit 100`;
-            // Try TABLESAMPLE first — it picks random micro-partitions without
-            // scanning the whole table, which avoids the full-scan problem on
-            // large partitioned tables. TABLESAMPLE only works on base tables,
-            // not views, so if it fails we fall back to a plain LIMIT 100.
-            const tablesampleClause = `select object_construct(${variantArgs}) o` +
-                ` from ${tablePath} TABLESAMPLE BLOCK (1) limit 100`;
-            const fieldPathRows = await this.runSchemaSample(makeSampleQuery(tablesampleClause), makeSampleQuery(limitClause));
+            const projectVariants = `select object_construct(${variantArgs}) o`;
+            const probe = await this.probeTableSize(tablePath);
+            const strategy = pickSampleStrategy(probe, this.schemaSampleFullScanMaxBytes);
+            const n = this.schemaSampleRowLimit;
+            let fieldPathRows;
+            if (strategy === 'full-scan-then-sample') {
+                // Small base table: one full scan catches rare fields that
+                // sampling would miss. tryBatch so a failure doesn't poison
+                // the pool connection (temp views live on it). On failure we
+                // fall through to the sample path so a slow or timed-out full
+                // scan still gets partial structure.
+                fieldPathRows =
+                    (_a = (await this.executor.tryBatch(makeSampleQuery(`${projectVariants} from ${tablePath}`), {}, this.schemaSampleTimeoutMs))) !== null && _a !== void 0 ? _a : undefined;
+            }
             if (fieldPathRows === undefined) {
-                // Both attempts failed or timed out — treat variants as opaque.
-                for (const name of variants) {
-                    structDef.fields.push({ type: 'sql native', rawType: 'variant', name });
+                const tablesampleQuery = makeSampleQuery(`${projectVariants} from ${tablePath} TABLESAMPLE BLOCK (1) limit ${n}`);
+                if (strategy === 'tablesample-only') {
+                    // Known-large base table: TABLESAMPLE is safe (reads a few
+                    // micro-partitions), plain LIMIT without a WHERE can be
+                    // catastrophic on large partitioned tables. If TABLESAMPLE
+                    // fails here we accept variant rather than risk an unbounded
+                    // scan.
+                    fieldPathRows =
+                        (_b = (await this.executor.tryBatch(tablesampleQuery, {}, this.schemaSampleTimeoutMs))) !== null && _b !== void 0 ? _b : undefined;
+                }
+                else {
+                    // Unknown size (view, temp view, non-parseable name) or
+                    // full-scan fallback: best-effort TABLESAMPLE→LIMIT chain.
+                    // The LIMIT fallback is the acknowledged "can't help" case
+                    // for views over large partitioned tables.
+                    fieldPathRows = await this.runSchemaSample(tablesampleQuery, makeSampleQuery(`${projectVariants} from ${tablePath} limit ${n}`));
                 }
             }
-            else {
-                // Take the schema in list form and convert it into a tree.
-                const rootObject = new SnowObject('__root__', this.dialect);
+            const state = (0, snowflake_variant_schema_1.createVariantSchemaState)();
+            // Snowflake nested-schema inference follows these rules:
+            // - top-level ARRAY/OBJECT from DESCRIBE are authoritative
+            // - descendant paths imply ancestor shape
+            // - conflicting shapes degrade only that prefix to variant
+            // - every top-level nested column still produces a field
+            for (const nestedColumn of nestedColumns) {
+                (0, snowflake_variant_schema_1.seedTopLevelShape)(state, nestedColumn);
+            }
+            if (fieldPathRows !== undefined) {
                 for (const f of fieldPathRows) {
-                    const pathString = (_a = f['PATH']) === null || _a === void 0 ? void 0 : _a.valueOf().toString();
-                    const fieldType = (_b = f['TYPE']) === null || _b === void 0 ? void 0 : _b.valueOf().toString();
+                    const pathString = (_c = f['PATH']) === null || _c === void 0 ? void 0 : _c.valueOf().toString();
+                    const fieldType = (_d = f['TYPE']) === null || _d === void 0 ? void 0 : _d.valueOf().toString();
                     if (pathString === undefined || fieldType === undefined)
                         continue;
-                    const pathParser = new PathParser(pathString);
-                    const path = pathParser.pathChain();
-                    if ('name' in path && notVariant.get(path.name)) {
+                    const pathParser = new snowflake_variant_schema_1.PathParser(pathString);
+                    const segments = pathParser.segments();
+                    const topLevel = segments[0];
+                    if ((topLevel === null || topLevel === void 0 ? void 0 : topLevel.kind) !== 'name' || notVariant.get(topLevel.name)) {
                         continue;
                     }
-                    rootObject.walk(path, fieldType);
+                    (0, snowflake_variant_schema_1.accumulateVariantPath)(state, segments, fieldType);
                 }
-                structDef.fields.push(...rootObject.fields);
+            }
+            // Always emit one field per top-level nested column from DESCRIBE, even
+            // if sampling produced no usable descendant paths.
+            for (const nestedColumn of nestedColumns) {
+                structDef.fields.push((0, snowflake_variant_schema_1.buildTopLevelField)(nestedColumn, state, this.dialect));
             }
         }
     }
+    /**
+     * Cheap metadata probe: ask INFORMATION_SCHEMA.TABLES for the row count
+     * and byte size of tablePath. Returns undefined when the name doesn't
+     * parse as a two- or three-part identifier, when the probe query fails,
+     * or when the row has no numeric BYTES (views and external tables
+     * typically report NULL).
+     *
+     * Two-part `schema.table` names use the current database's
+     * INFORMATION_SCHEMA; three-part `db.schema.table` names address
+     * INFORMATION_SCHEMA in the named database. Identifiers are parsed
+     * with Snowflake's quoting rules so bare parts case-fold to upper and
+     * quoted parts are compared verbatim against the catalog.
+     */
+    async probeTableSize(tablePath) {
+        var _a, _b;
+        const parsed = (0, snowflake_table_name_1.parseSnowflakeTableName)(tablePath);
+        if (parsed === undefined || parsed.schema === undefined)
+            return undefined;
+        const quoteLit = (s) => s.replace(/'/g, "''");
+        const dbQualifier = parsed.database ? `${parsed.database.sql}.` : '';
+        const rows = await this.executor.tryBatch(`select row_count as rc, bytes as by
+       from ${dbQualifier}information_schema.tables
+       where table_schema = '${quoteLit(parsed.schema.literal)}'
+         and table_name = '${quoteLit(parsed.table.literal)}'
+       limit 1`, {}, this.schemaSampleTimeoutMs);
+        if (!rows || rows.length === 0)
+            return undefined;
+        const row = rows[0];
+        const bytesRaw = (_a = row['BY']) !== null && _a !== void 0 ? _a : row['by'];
+        const rowsRaw = (_b = row['RC']) !== null && _b !== void 0 ? _b : row['rc'];
+        // Views and external tables surface null BYTES / ROW_COUNT; treat
+        // that as "unknown size" so we don't classify them as small and
+        // launch a full scan against something potentially huge.
+        if (bytesRaw === null || bytesRaw === undefined)
+            return undefined;
+        if (rowsRaw === null || rowsRaw === undefined)
+            return undefined;
+        const bytes = Number(bytesRaw);
+        const rowCount = Number(rowsRaw);
+        if (!Number.isFinite(bytes) || !Number.isFinite(rowCount))
+            return undefined;
+        return { bytes, rowCount };
+    }
     /**
      * Try to run a schema sampling query, with fallback.
      * First tries the primary query (e.g. using TABLESAMPLE for speed).
@@ -373,56 +341,4 @@ class SnowflakeConnection extends connection_1.BaseConnection {
     }
 }
 exports.SnowflakeConnection = SnowflakeConnection;
-class PathParser extends malloy_1.TinyParser {
-    constructor(pathName) {
-        super(pathName, {
-            quoted: /^'(\\'|[^'])*'/,
-            array_of: /^\[\*]/,
-            char: /^[[.\]]/,
-            number: /^\d+/,
-            word: /^\w+/,
-        });
-    }
-    getName() {
-        const nameStart = this.next();
-        if (nameStart.type === 'word') {
-            return nameStart.text;
-        }
-        if (nameStart.type === '[') {
-            const quotedName = this.next('quoted');
-            this.next(']');
-            return quotedName.text;
-        }
-        throw this.parseError('Expected column name');
-    }
-    pathChain() {
-        const chain = { name: this.getName() };
-        let node = chain;
-        for (;;) {
-            const sep = this.next();
-            if (sep.type === 'eof') {
-                return chain;
-            }
-            if (sep.type === '.') {
-                node.next = { name: this.next('word').text };
-                node = node.next;
-            }
-            else if (sep.type === 'array_of') {
-                node.next = { arrayRef: true };
-                node = node.next;
-            }
-            else if (sep.type === '[') {
-                // Actually a dot access through a quoted name
-                const quoted = this.next('quoted');
-                node.next = { name: quoted.text };
-                node = node.next;
-                this.next(']');
-            }
-            else {
-                throw this.parseError(`Unexpected ${sep.type}`);
-            }
-        }
-    }
-}
-exports.PathParser = PathParser;
 //# sourceMappingURL=snowflake_connection.js.map