@malloydata/db-snowflake 0.0.374 → 0.0.376

package/dist/snowflake_variant_schema.spec.js

@@ -0,0 +1,150 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const malloy_1 = require("@malloydata/malloy");
+const snowflake_variant_schema_1 = require("./snowflake_variant_schema");
+describe('snowflake variant schema helper', () => {
+    const dialect = new malloy_1.SnowflakeDialect();
+    function inferField(nestedColumn, rows) {
+        const state = (0, snowflake_variant_schema_1.createVariantSchemaState)();
+        (0, snowflake_variant_schema_1.seedTopLevelShape)(state, nestedColumn);
+        for (const row of rows) {
+            (0, snowflake_variant_schema_1.accumulateVariantPath)(state, new snowflake_variant_schema_1.PathParser(row.path).segments(), row.type);
+        }
+        return (0, snowflake_variant_schema_1.buildTopLevelField)(nestedColumn, state, dialect);
+    }
+    test('reconstructs object shape from descendant-only evidence', () => {
+        expect(inferField({ kind: 'variant', name: 'BASE_TOUCHPOINT' }, [
+            { path: 'BASE_TOUCHPOINT.NETWORK', type: 'varchar' },
+            { path: 'BASE_TOUCHPOINT.PLATFORM', type: 'varchar' },
+        ])).toEqual({
+            type: 'record',
+            name: 'BASE_TOUCHPOINT',
+            join: 'one',
+            fields: [
+                { name: 'NETWORK', type: 'string' },
+                { name: 'PLATFORM', type: 'string' },
+            ],
+        });
+    });
+    test('degrades object-array conflict at a shared prefix', () => {
+        expect(inferField({ kind: 'variant', name: 'X' }, [
+            { path: 'X.Y', type: 'varchar' },
+            { path: 'X[*].Z', type: 'decimal' },
+        ])).toEqual({
+            type: 'sql native',
+            rawType: 'variant',
+            name: 'X',
+        });
+    });
+    test('builds array of records from stable descendants', () => {
+        expect(inferField({ kind: 'variant', name: 'ITEMS' }, [
+            { path: 'ITEMS[*].FOO', type: 'varchar' },
+            { path: 'ITEMS[*].BAR', type: 'boolean' },
+        ])).toEqual({
+            type: 'array',
+            name: 'ITEMS',
+            join: 'many',
+            elementTypeDef: { type: 'record_element' },
+            fields: [
+                { name: 'FOO', type: 'string' },
+                { name: 'BAR', type: 'boolean' },
+            ],
+        });
+    });
+    test('top-level array with no descendants becomes array of variant', () => {
+        expect(inferField({ kind: 'array', name: 'DIMENSION_SET_IDS' }, [])).toEqual({
+            type: 'array',
+            name: 'DIMENSION_SET_IDS',
+            join: 'many',
+            elementTypeDef: { type: 'sql native', rawType: 'variant' },
+            fields: [
+                { name: 'value', type: 'sql native', rawType: 'variant' },
+                {
+                    name: 'each',
+                    type: 'sql native',
+                    rawType: 'variant',
+                    e: { node: 'field', path: ['value'] },
+                },
+            ],
+        });
+    });
+    test('top-level DESCRIBE seed stays authoritative over conflicting sample', () => {
+        expect(inferField({ kind: 'array', name: 'DIMENSION_SET_IDS' }, [
+            { path: 'DIMENSION_SET_IDS.foo', type: 'varchar' },
+        ])).toEqual({
+            type: 'array',
+            name: 'DIMENSION_SET_IDS',
+            join: 'many',
+            elementTypeDef: { type: 'sql native', rawType: 'variant' },
+            fields: [
+                { name: 'value', type: 'sql native', rawType: 'variant' },
+                {
+                    name: 'each',
+                    type: 'sql native',
+                    rawType: 'variant',
+                    e: { node: 'field', path: ['value'] },
+                },
+            ],
+        });
+    });
+    test('top-level object with no descendants becomes opaque variant', () => {
+        expect(inferField({ kind: 'object', name: 'PAYLOAD' }, [])).toEqual({
+            type: 'sql native',
+            rawType: 'variant',
+            name: 'PAYLOAD',
+        });
+    });
+    test('quoted path names with punctuation are preserved', () => {
+        expect(inferField({ kind: 'variant', name: 'DATA' }, [
+            { path: "DATA['a.b'][*]['c[d]']", type: 'varchar' },
+        ])).toEqual({
+            type: 'record',
+            name: 'DATA',
+            join: 'one',
+            fields: [
+                {
+                    type: 'array',
+                    name: 'a.b',
+                    join: 'many',
+                    elementTypeDef: { type: 'record_element' },
+                    fields: [{ name: 'c[d]', type: 'string' }],
+                },
+            ],
+        });
+    });
+    test('leaf-type conflicts degrade to variant', () => {
+        const first = { kind: 'leaf', type: 'varchar' };
+        const second = { kind: 'leaf', type: 'decimal' };
+        expect((0, snowflake_variant_schema_1.mergeShape)(first, second)).toEqual({ kind: 'variant' });
+    });
+    test('scalar-vs-object at same path degrades that field only', () => {
+        // The sample emits both the scalar observation and the object
+        // observation (same path, two rows from the distinct (path, type)
+        // query). mergeShape collapses DATA.foo to variant; the parent
+        // DATA stays a record and siblings keep their types.
+        expect(inferField({ kind: 'variant', name: 'DATA' }, [
+            { path: 'DATA.foo', type: 'object' },
+            { path: 'DATA.foo', type: 'varchar' },
+            { path: 'DATA.foo.bar', type: 'decimal' },
+            { path: 'DATA.sib', type: 'varchar' },
+        ])).toEqual({
+            type: 'record',
+            name: 'DATA',
+            join: 'one',
+            fields: [
+                { type: 'sql native', rawType: 'variant', name: 'foo' },
+                { type: 'string', name: 'sib' },
+            ],
+        });
+    });
+    test('variant shape is monotonic', () => {
+        expect((0, snowflake_variant_schema_1.mergeShape)({ kind: 'variant' }, { kind: 'object' })).toEqual({
+            kind: 'variant',
+        });
+    });
+});
+//# sourceMappingURL=snowflake_variant_schema.spec.js.map

package/dist/snowflake_variant_schema.spec.js.map

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/db-snowflake",
-  "version": "0.0.374",
+  "version": "0.0.376",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -22,7 +22,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@malloydata/malloy": "0.0.374",
+    "@malloydata/malloy": "0.0.376",
     "generic-pool": "^3.9.0",
     "snowflake-sdk": "2.3.1",
     "toml": "^3.0.0"

package/src/index.ts

@@ -37,6 +37,8 @@ registerConnectionType('snowflake', {
       setupSQL,
       timeoutMs,
       schemaSampleTimeoutMs,
+      schemaSampleRowLimit,
+      schemaSampleFullScanMaxBytes,
       ...props
     } = config;
     // ConnectionConfig values are trusted to match ConnectionOptions fields
@@ -60,6 +62,18 @@ registerConnectionType('snowflake', {
           : 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: [
@@ -101,14 +115,33 @@ registerConnectionType('snowflake', {
       displayName: 'Timeout (ms)',
       type: 'number',
       optional: true,
+      default: 600000,
     },
     {
       name: 'schemaSampleTimeoutMs',
       displayName: 'Schema Sample Timeout (ms)',
       type: 'number',
       optional: true,
+      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:
-        'Timeout for the query that samples variant columns to detect their schema (default 15000)',
+        '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/src/snowflake_connection.spec.ts

@@ -129,7 +129,7 @@ describe('db:Snowflake', () => {
   it('discovers variant schema through a view', async () => {
     // Create a view with a variant column, then fetch its schema.
     // This exercises the TABLESAMPLE fallback path — TABLESAMPLE fails
-    // on views, so the code should fall back to LIMIT 100.
+    // on views, so the code should fall back to a plain LIMIT sample.
     const salt = Math.random().toString(36).slice(2, 10);
     const viewName = `malloytest.test_variant_view_${salt}`;
     await conn.runSQL(
@@ -147,6 +147,38 @@ describe('db:Snowflake', () => {
     }
   });
 
+  it('preserves top-level array shape when sample rows have no descendants', async () => {
+    // ARRAY comes from DESCRIBE TABLE, so even if recursive flatten sees no
+    // element paths we should still return an array<variant> field.
+    const salt = Math.random().toString(36).slice(2, 10);
+    const viewName = `malloytest.test_array_seed_${salt}`;
+    await conn.runSQL(
+      `CREATE OR REPLACE VIEW ${viewName} AS
+       SELECT ARRAY_CONSTRUCT() AS data`
+    );
+    try {
+      const schema = await conn.fetchTableSchema(viewName, viewName);
+      const dataField = schema.fields.find(f => f.name === 'DATA');
+      expect(dataField).toEqual({
+        type: 'array',
+        name: 'DATA',
+        join: 'many',
+        elementTypeDef: {type: 'sql native', rawType: 'variant'},
+        fields: [
+          {name: 'value', type: 'sql native', rawType: 'variant'},
+          {
+            name: 'each',
+            type: 'sql native',
+            rawType: 'variant',
+            e: {node: 'field', path: ['value']},
+          },
+        ],
+      });
+    } finally {
+      await conn.runSQL(`DROP VIEW IF EXISTS ${viewName}`);
+    }
+  });
+
   it('maps integer types to bigint', async () => {
     const x: malloy.SQLSourceDef = {
       type: 'sql_select',
@@ -170,16 +202,18 @@ describe('db:Snowflake', () => {
     ]);
   });
 
-  it('degrades variant field to sql native when types conflict across rows', async () => {
-    // data.foo is a scalar in one row and an object in another.
-    // Schema discovery should not throw — foo should degrade to sql native.
+  it('degrades scalar-vs-object field to sql native without losing siblings', async () => {
+    // data.foo is an object in one row and a scalar in another. Honest
+    // policy: foo becomes sql native variant (caller must cast with
+    // `foo :: {bar :: number}` to query bar). The enclosing record is
+    // unaffected — sibling fields keep their inferred types.
     const salt = Math.random().toString(36).slice(2, 10);
     const viewName = `malloytest.test_variant_conflict_${salt}`;
     await conn.runSQL(
       `CREATE OR REPLACE VIEW ${viewName} AS
-       SELECT parse_json('{"foo": {"bar": 1}}') AS data
+       SELECT parse_json('{"foo": {"bar": 1}, "sib": "hello"}') AS data
        UNION ALL
-       SELECT parse_json('{"foo": "oops"}') AS data`
+       SELECT parse_json('{"foo": "oops", "sib": "world"}') AS data`
     );
     try {
       const schema = await conn.fetchTableSchema(viewName, viewName);
@@ -193,22 +227,24 @@ describe('db:Snowflake', () => {
           rawType: 'variant',
           name: 'foo',
         });
+        const sibField = dataField!.fields.find(f => f.name === 'sib');
+        expect(sibField).toEqual({type: 'string', name: 'sib'});
       }
     } finally {
       await conn.runSQL(`DROP VIEW IF EXISTS ${viewName}`);
     }
   });
 
-  it('degrades nested object inside array when types conflict', async () => {
-    // Array analogue of the customer bug: items[*].foo is an object in
-    // one row and a scalar in another. foo should degrade to sql native.
+  it('degrades scalar-vs-object inside an array element without losing the array', async () => {
+    // Array analogue: items[*].foo is an object in one row and a scalar
+    // in another. foo degrades to variant; items stays array<record>.
     const salt = Math.random().toString(36).slice(2, 10);
     const viewName = `malloytest.test_variant_array_obj_conflict_${salt}`;
     await conn.runSQL(
       `CREATE OR REPLACE VIEW ${viewName} AS
-       SELECT parse_json('{"items": [{"foo": {"bar": 1}}]}') AS data
+       SELECT parse_json('{"items": [{"foo": {"bar": 1}, "sib": "a"}]}') AS data
        UNION ALL
-       SELECT parse_json('{"items": [{"foo": "oops"}]}') AS data`
+       SELECT parse_json('{"items": [{"foo": "oops", "sib": "b"}]}') AS data`
     );
     try {
       const schema = await conn.fetchTableSchema(viewName, viewName);
@@ -229,6 +265,8 @@ describe('db:Snowflake', () => {
             rawType: 'variant',
             name: 'foo',
           });
+          const sibField = itemsField!.fields.find(f => f.name === 'sib');
+          expect(sibField).toEqual({type: 'string', name: 'sib'});
         }
       }
     } finally {
@@ -236,6 +274,41 @@ describe('db:Snowflake', () => {
     }
   });
 
+  it('full-scans a small base table with variant columns under the byte threshold', async () => {
+    // Base table (not view) small enough that BYTES lands under the
+    // default 100 MB schemaSampleFullScanMaxBytes. The probe sees the
+    // size and the code takes the full-scan branch — no TABLESAMPLE,
+    // no LIMIT. Every row contributes to the (path, type) histogram,
+    // so rare fields are caught.
+    const salt = Math.random().toString(36).slice(2, 10);
+    const tableName = `malloytest.test_variant_fullscan_${salt}`;
+    await conn.runSQL(
+      `CREATE OR REPLACE TABLE ${tableName} AS
+       SELECT parse_json('{"foo": 1, "bar": "hi"}') AS data
+       UNION ALL
+       SELECT parse_json('{"foo": 2, "bar": "bye"}') AS data`
+    );
+    try {
+      const schema = await conn.fetchTableSchema(tableName, tableName);
+      const dataField = schema.fields.find(f => f.name === 'DATA');
+      expect(dataField).toBeDefined();
+      expect(dataField!.type).toBe('record');
+      if (dataField!.type === 'record') {
+        expect(dataField!.fields.find(f => f.name === 'foo')).toEqual({
+          name: 'foo',
+          type: 'number',
+          numberType: 'bigint',
+        });
+        expect(dataField!.fields.find(f => f.name === 'bar')).toEqual({
+          name: 'bar',
+          type: 'string',
+        });
+      }
+    } finally {
+      await conn.runSQL(`DROP TABLE IF EXISTS ${tableName}`);
+    }
+  });
+
   it('degrades when same path is object in one row and array in another', async () => {
     // foo is an object in one row and an array in another.
     // foo should degrade to sql native.
@@ -265,9 +338,10 @@ describe('db:Snowflake', () => {
     }
   });
 
-  it('preserves sibling fields when one field degrades', async () => {
-    // foo has conflicting types but stable is consistent.
-    // stable should come through normally.
+  it('preserves sibling fields when one field degrades to variant', async () => {
+    // foo is scalar in one row and object in another, while stable is
+    // always consistent. The degradation should stay local to foo and
+    // keep stable untouched.
     const salt = Math.random().toString(36).slice(2, 10);
     const viewName = `malloytest.test_variant_sibling_${salt}`;
     await conn.runSQL(