@malloydata/malloy 0.0.319 → 0.0.321

package/dist/lang/composite-source-utils.js

@@ -925,7 +925,7 @@ function isSingleValueFilterNode(e) {
                 return [];
             if ((result.parsed.operator === 'null' && !result.parsed.not) ||
                 (result.kind === 'boolean' &&
-                    ['false', 'true'].includes(result.parsed.operator) &&
+                    ['true', '=false', '=true'].includes(result.parsed.operator) &&
                     !result.parsed.not) ||
                 (result.kind === 'date' &&
                     result.parsed.operator === 'in' &&

package/dist/lang/test/test-translator.d.ts

@@ -7,7 +7,16 @@ import type { DataRequestResponse, SQLSourceRequest, TranslateResponse } from '.
 import type { ExprValue } from '../ast/types/expr-value';
 import type { LogSeverity, MessageCode, MessageParameterType } from '../parse-log';
 import type { EventStream } from '../../runtime_types';
-export declare function pretty(thing: any): string;
+export declare function pretty(thing: unknown): string;
+/**
+ * For human inspection of IR objects, there is a lot of noise which makes
+ * it diifficult to read. This function makes a deep copy of the object
+ * stripping out location meta data and and fields with undefined values.
+ * Then it pretty-prints the result.
+ * @param value Some IR object
+ * @returns prettified printable version
+ */
+export declare function humanify(value: unknown): string;
 export declare const aTableDef: SourceDef;
 /**
  * When translating partial trees, there will not be a document node

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

@@ -25,6 +25,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BetaExpression = exports.TestTranslator = exports.TestChildTranslator = exports.aTableDef = void 0;
 exports.pretty = pretty;
+exports.humanify = humanify;
 exports.getExplore = getExplore;
 exports.getModelQuery = getModelQuery;
 exports.getFieldDef = getFieldDef;
@@ -48,9 +49,88 @@ const parse_malloy_1 = require("../parse-malloy");
 const static_space_1 = require("../ast/field-space/static-space");
 const global_name_space_1 = require("../ast/types/global-name-space");
 const sql_block_1 = require("../../model/sql_block");
-// eslint-disable-next-line @typescript-eslint/no-explicit-any,@typescript-eslint/explicit-module-boundary-types
 function pretty(thing) {
-    return (0, util_1.inspect)(thing, { breakLength: 72, depth: Infinity });
+    return (0, util_1.inspect)(thing, { breakLength: 100, depth: Infinity });
+}
+/**
+ * For human inspection of IR objects, there is a lot of noise which makes
+ * it diifficult to read. This function makes a deep copy of the object
+ * stripping out location meta data and and fields with undefined values.
+ * Then it pretty-prints the result.
+ * @param value Some IR object
+ * @returns prettified printable version
+ */
+function humanify(value) {
+    const seen = new WeakMap();
+    function isObject(u) {
+        return typeof u === 'object' && u !== null;
+    }
+    function walk(u) {
+        // primitives & null
+        if (u === null || typeof u !== 'object')
+            return u;
+        // Date
+        if (u instanceof Date)
+            return new Date(u.getTime());
+        // RegExp
+        if (u instanceof RegExp)
+            return new RegExp(u.source, u.flags);
+        // Already visited (handle cycles)
+        if (seen.has(u))
+            return seen.get(u);
+        // Array
+        if (Array.isArray(u)) {
+            const out = [];
+            seen.set(u, out);
+            for (let i = 0; i < u.length; i++) {
+                out[i] = walk(u[i]);
+            }
+            return out;
+        }
+        // Map
+        if (u instanceof Map) {
+            const out = new Map();
+            seen.set(u, out);
+            for (const [k, v] of u.entries()) {
+                out.set(k, walk(v));
+            }
+            return out;
+        }
+        // Set
+        if (u instanceof Set) {
+            const out = new Set();
+            seen.set(u, out);
+            for (const v of u.values()) {
+                out.add(walk(v));
+            }
+            return out;
+        }
+        // Plain object or class instance: copy enumerable own properties,
+        // skipping keys "at" and "location"
+        if (isObject(u)) {
+            const out = {};
+            seen.set(u, out);
+            const src = u;
+            for (const key of Object.keys(src)) {
+                // skip location metadata
+                if (key === 'at' || key === 'location')
+                    continue;
+                const val = src[key];
+                // drop properties that exist but have undefined value
+                if (val === undefined)
+                    continue;
+                const w = walk(val);
+                // if the walked value is undefined, skip adding the property
+                if (w === undefined)
+                    continue;
+                out[key] = w;
+            }
+            return out;
+        }
+        // Fallback
+        return u;
+    }
+    return pretty(walk(value));
 }
 const intType = { type: 'number', numberType: 'integer' };
 const mockSchema = {

package/dist/model/filter_compilers.d.ts

@@ -3,7 +3,7 @@ import type { Dialect, QueryInfo } from '../dialect';
 export declare const FilterCompilers: {
     compile(t: string, c: FilterExpression | null, x: string, d: Dialect, qi?: QueryInfo): string;
     numberCompile(nc: NumberFilter, x: string, d: Dialect): string;
-    booleanCompile(bc: BooleanFilter, x: string, _d: Dialect): string;
+    booleanCompile(bc: BooleanFilter, x: string, d: Dialect): string;
     stringCompile(sc: StringFilter, x: string, d: Dialect): string;
     temporalCompile(tc: TemporalFilter, x: string, d: Dialect, t: "date" | "timestamp", qi?: QueryInfo): string;
 };

package/dist/model/filter_compilers.js

@@ -100,19 +100,52 @@ exports.FilterCompilers = {
                     .join(` ${nc.operator.toUpperCase()} `);
         }
     },
-    booleanCompile(bc, x, _d) {
-        switch (bc.operator) {
-            case 'true':
-                return bc.not ? `NOT COALESCE(${x}, false)` : `COALESCE(${x}, false)`;
-            case 'false':
+    booleanCompile(bc, x, d) {
+        const px = `(${x})`;
+        /*
+         * We have the following truth table for boolean filters.
+         * The default malloy operations treat null as false. The '='
+         * variants exist for cases where that is not desired.
+         *
+         * filter expression | x=true | x=false | x=null
+         * true              |   T    |   F     |   F
+         * not true          |   F    |   T     |   T
+         * =true             |   T    |   F     |   NULL
+         * not =true         |   F    |   T     |   NULL
+         * false             |   F    |   T     |   T
+         * not false         |   T    |   F     |   F
+         * =false            |   F    |   T     |   NULL
+         * not =false        |   T    |   F     |   NULL
+         */
+        if (bc.operator === '=true') {
+            return bc.not ? `NOT ${px}` : x;
+        }
+        else if (bc.operator === '=false') {
+            return bc.not ? x : `NOT ${px}`;
+        }
+        else if (bc.operator === 'null') {
+            return bc.not ? `${px} IS NOT NULL` : `${px} IS NULL`;
+        }
+        // For some databases checking NULL combined with a boolean check
+        // is faster than a COALESCE, for now, just detect if the expression
+        // is just a column reference, and if so, don't use COALECSE.
+        const quoteChar = d.sqlMaybeQuoteIdentifier('select')[0];
+        const isColumn = x.match(`^[()${quoteChar}\\w.]+$`);
+        if (isColumn) {
+            if (bc.operator === 'true') {
                 return bc.not
-                    ? `COALESCE(${x} != false, true)`
-                    : `COALESCE(${x} = false, false)`;
-            case 'false_or_null':
-                return bc.not ? `COALESCE(${x}, false)` : `NOT COALESCE(${x}, false)`;
-            case 'null':
-                return bc.not ? `${x} IS NOT NULL` : `${x} IS NULL`;
+                    ? `${px} IS NULL OR ${px} = false`
+                    : `${px} IS NOT NULL AND ${px}`;
+            }
+            return bc.not
+                ? `${px} IS NOT NULL AND ${px}` // not false: exclude null
+                : `${px} IS NULL OR ${px} = false`; // false: include null
+        }
+        if (bc.operator === 'true') {
+            return bc.not ? `NOT COALESCE(${x}, false)` : `COALESCE(${x}, false)`;
         }
+        // else bc.operator === 'false'
+        return bc.not ? `COALESCE(${x}, false)` : `NOT COALESCE(${x}, false)`;
     },
     stringCompile(sc, x, d) {
         switch (sc.operator) {

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const MALLOY_VERSION = "0.0.319";
+export declare const MALLOY_VERSION = "0.0.321";

package/dist/version.js

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MALLOY_VERSION = void 0;
 // generated with 'generate-version-file' script; do not edit manually
-exports.MALLOY_VERSION = '0.0.319';
+exports.MALLOY_VERSION = '0.0.321';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.319",
+  "version": "0.0.321",
   "license": "MIT",
   "exports": {
     ".": "./dist/index.js",
@@ -41,9 +41,9 @@
     "generate-version-file": "VERSION=$(npm pkg get version --workspaces=false | tr -d \\\")\necho \"// generated with 'generate-version-file' script; do not edit manually\\nexport const MALLOY_VERSION = '$VERSION';\" > src/version.ts"
   },
   "dependencies": {
-    "@malloydata/malloy-filter": "0.0.319",
-    "@malloydata/malloy-interfaces": "0.0.319",
-    "@malloydata/malloy-tag": "0.0.319",
+    "@malloydata/malloy-filter": "0.0.321",
+    "@malloydata/malloy-interfaces": "0.0.321",
+    "@malloydata/malloy-tag": "0.0.321",
     "antlr4ts": "^0.5.0-alpha.4",
     "assert": "^2.0.0",
     "jaro-winkler": "^0.2.8",