@malloydata/malloy 0.0.23 → 0.0.24-dev230215185525

package/dist/lang/ast/expressions/expr-id-reference.js

@@ -41,10 +41,8 @@ class ExprIdReference extends expression_def_1.ExpressionDef {
         const def = this.fieldReference.getField(fs);
         if (def.found) {
             const value = [{ "type": def.found.refType, "path": this.refString }];
-            return {
-                ...def.found.typeDesc(),
-                value
-            };
+            const td = def.found.typeDesc();
+            return { ...td, value };
         }
         this.log(def.error);
         return (0, ast_utils_1.errorFor)(def.error);

package/dist/lang/ast/expressions/expr-logical-op.d.ts

@@ -5,5 +5,6 @@ export declare class ExprLogicalOp extends BinaryBoolean<"and" | "or"> {
         aggregate: boolean;
         dataType: import("../types/type-desc").FieldValueType;
         expressionType: import("../../..").ExpressionType;
+        rawType?: string | undefined;
     })[];
 }

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

@@ -23,7 +23,6 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprNot = void 0;
-const ast_utils_1 = require("../ast-utils");
 const fragtype_utils_1 = require("../fragtype-utils");
 const unary_1 = require("./unary");
 const utils_1 = require("./utils");
@@ -35,14 +34,12 @@ class ExprNot extends unary_1.Unary {
     }
     getExpression(fs) {
         const notThis = this.expr.getExpression(fs);
-        if (this.typeCheck(this.expr, notThis)) {
-            return {
-                ...notThis,
-                "dataType": "boolean",
-                "value": (0, utils_1.nullsafeNot)(notThis.value)
-            };
-        }
-        return (0, ast_utils_1.errorFor)("not requires boolean");
+        const doNot = this.typeCheck(this.expr, notThis);
+        return {
+            ...notThis,
+            "dataType": "boolean",
+            "value": doNot ? (0, utils_1.nullsafeNot)(notThis.value) : ["false"]
+        };
     }
 }
 exports.ExprNot = ExprNot;

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

@@ -197,6 +197,18 @@ function nullCompare(left, op, right) {
 function equality(fs, left, op, right) {
     const lhs = left.getExpression(fs);
     const rhs = right.getExpression(fs);
+    // Unsupported types can be compare with null
+    const checkUnsupport = lhs.dataType === "unsupported" || rhs.dataType === "unsupported";
+    if (checkUnsupport) {
+        const oneNull = lhs.dataType === "null" || rhs.dataType === "null";
+        const rawMatch = lhs.rawType && lhs.rawType === rhs.rawType;
+        if (!(oneNull || rawMatch)) {
+            const noGo = unsupportError(left, lhs, right, rhs);
+            if (noGo) {
+                return { ...noGo, "dataType": "boolean" };
+            }
+        }
+    }
     let value = timeCompare(lhs, op, rhs) || (0, utils_1.compose)(lhs.value, op, rhs.value);
     if (lhs.dataType != "unknown" && rhs.dataType != "unknown") {
         switch (op) {
@@ -238,6 +250,10 @@ function compare(fs, left, op, right) {
     const lhs = left.getExpression(fs);
     const rhs = right.getExpression(fs);
     const expressionType = (0, malloy_types_1.maxExpressionType)(lhs.expressionType, rhs.expressionType);
+    const noCompare = unsupportError(left, lhs, right, rhs);
+    if (noCompare) {
+        return { ...noCompare, "dataType": "boolean" };
+    }
     const value = timeCompare(lhs, op, rhs) || (0, utils_1.compose)(lhs.value, op, rhs.value);
     return {
         "dataType": "boolean",
@@ -259,6 +275,10 @@ function allAre(oneType, ...values) {
 function numeric(fs, left, op, right) {
     const lhs = left.getExpression(fs);
     const rhs = right.getExpression(fs);
+    const noGo = unsupportError(left, lhs, right, rhs);
+    if (noGo) {
+        return noGo;
+    }
     const expressionType = (0, malloy_types_1.maxExpressionType)(lhs.expressionType, rhs.expressionType);
     if (allAre("number", lhs, rhs)) {
         return {
@@ -273,6 +293,10 @@ function numeric(fs, left, op, right) {
 function delta(fs, left, op, right) {
     const lhs = left.getExpression(fs);
     const rhs = right.getExpression(fs);
+    const noGo = unsupportError(left, lhs, right, rhs);
+    if (noGo) {
+        return noGo;
+    }
     if ((0, malloy_types_1.isTimeFieldType)(lhs.dataType)) {
         let duration = right;
         if (rhs.dataType !== "duration") {
@@ -318,6 +342,11 @@ function applyBinary(fs, left, op, right) {
     if (oneOf(op, "/")) {
         const num = left.getExpression(fs);
         const denom = right.getExpression(fs);
+        const noGo = unsupportError(left, num, right, denom);
+        if (noGo) {
+            left.log("Cannot operate with unsupported type");
+            return noGo;
+        }
         if (num.dataType != "number") {
             left.log("Numerator for division must be a number");
         }
@@ -343,4 +372,23 @@ function applyBinary(fs, left, op, right) {
     return (0, ast_utils_1.errorFor)("applybinary bad operator");
 }
 exports.applyBinary = applyBinary;
+/**
+ * Return an error if an binary operation includes unsupported types.
+ */
+function unsupportError(l, lhs, r, rhs) {
+    const ret = {
+        "dataType": lhs.dataType,
+        "expressionType": (0, malloy_types_1.maxExpressionType)(lhs.expressionType, rhs.expressionType),
+        "value": ["'unsupported operation'"]
+    };
+    if (lhs.dataType === "unsupported") {
+        l.log("Unsupported type not allowed in expression");
+        return { ...ret, "dataType": rhs.dataType };
+    }
+    if (rhs.dataType === "unsupported") {
+        r.log("Unsupported type not allowed in expression");
+        return ret;
+    }
+    return undefined;
+}
 //# sourceMappingURL=expression-def.js.map

package/dist/lang/ast/types/space-field.js

@@ -35,6 +35,11 @@ class SpaceField extends space_entry_1.SpaceEntry {
         if ((0, malloy_types_1.isFieldTypeDef)(def) && def.expressionType) {
             ref.expressionType = def.expressionType;
         }
+        if (ref.dataType === "unsupported" &&
+            def.type === "unsupported" &&
+            def.rawType) {
+            ref.rawType = def.rawType;
+        }
         return ref;
     }
     getQueryFieldDef(_fs) {

package/dist/lang/ast/types/type-desc.d.ts

@@ -4,4 +4,5 @@ export declare type FieldValueType = ExpressionValueType | "turtle" | "struct";
 export interface TypeDesc {
     dataType: FieldValueType;
     expressionType: ExpressionType;
+    rawType?: string;
 }

package/dist/lang/test/field-symbols.spec.js

@@ -91,6 +91,17 @@ describe("structdef comprehension", () => {
         const oField = space.structDef().fields[0];
         expect(oField).toEqual(field);
     });
+    test(`import unsupported field`, () => {
+        const field = {
+            "name": "t",
+            "type": "unsupported"
+        };
+        const struct = mkStructDef(field);
+        const space = new static_space_1.StaticSpace(struct);
+        expect(space.lookup(fieldRef("t")).found).toBeInstanceOf(column_space_field_1.ColumnSpaceField);
+        const oField = space.structDef().fields[0];
+        expect(oField).toEqual(field);
+    });
     test(`import nested field`, () => {
         const field = {
             "name": "t",

package/dist/lang/test/parse.spec.js

@@ -1088,6 +1088,38 @@ describe("expressions", () => {
         }
     });
 });
+describe("unspported fields in schema", () => {
+    test("unsupported reference in result allowed", () => {
+        const uModel = new BetaModel(`query: a->{ group_by: aun }`);
+        expect(uModel).modelCompiled();
+    });
+    test("unsupported reference can be compared to NULL", () => {
+        const uModel = new BetaModel(`query: a->{ where: aun != NULL; project: * }`);
+        expect(uModel).modelCompiled();
+    });
+    test("flag unsupported equality", () => {
+        // because we don't know if the two unsupported types are comparable
+        const uModel = new BetaModel(`query: ab->{ where: aun = b.aun  project: * }`);
+        expect(uModel).compileToFailWith("Unsupported type not allowed in expression");
+    });
+    test("flag unsupported compare", () => {
+        // because we don't know if the two unsupported types are comparable
+        const uModel = new BetaModel(`query: ab->{ where: aun > b.aun  project: * }`);
+        expect(uModel).compileToFailWith("Unsupported type not allowed in expression");
+    });
+    test("allow unsupported equality when raw types match", () => {
+        const uModel = new BetaModel(`query: ab->{ where: aweird = b.aweird  project: * }`);
+        expect(uModel).modelCompiled();
+    });
+    test("flag not applied to unsupported", () => {
+        const uModel = new BetaModel(`source: x is a { dimension: notUn is not aun }`);
+        expect(uModel).compileToFailWith("'not' Can't use type unsupported");
+    });
+    test("allow unsupported to be cast", () => {
+        const uModel = new BetaModel(`source: x is a { dimension: notUn is aun::string }`);
+        expect(uModel).modelCompiled();
+    });
+});
 describe("sql:", () => {
     function makeSchemaResponse(sql) {
         const cname = sql.connection || "bigquery";

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

@@ -45,7 +45,9 @@ const mockSchema = {
             { "type": "number", "name": "ai", "numberType": "integer" },
             { "type": "date", "name": "ad" },
             { "type": "boolean", "name": "abool" },
-            { "type": "timestamp", "name": "ats" }
+            { "type": "timestamp", "name": "ats" },
+            { "type": "unsupported", "name": "aun" },
+            { "type": "unsupported", "name": "aweird", "rawType": "weird" }
         ]
     },
     "malloytest.carriers": {

package/dist/malloy.d.ts

@@ -494,7 +494,8 @@ export declare enum AtomicFieldType {
     Boolean = "boolean",
     Date = "date",
     Timestamp = "timestamp",
-    Json = "json"
+    Json = "json",
+    Unsupported = "unsupported"
 }
 export declare class AtomicField extends Entity {
     protected fieldTypeDef: FieldTypeDef;

package/dist/malloy.js

@@ -986,6 +986,7 @@ var AtomicFieldType;
     AtomicFieldType["Date"] = "date";
     AtomicFieldType["Timestamp"] = "timestamp";
     AtomicFieldType["Json"] = "json";
+    AtomicFieldType["Unsupported"] = "unsupported";
 })(AtomicFieldType = exports.AtomicFieldType || (exports.AtomicFieldType = {}));
 class AtomicField extends Entity {
     constructor(fieldTypeDef, parent, source) {
@@ -1007,6 +1008,8 @@ class AtomicField extends Entity {
                 return AtomicFieldType.Number;
             case "json":
                 return AtomicFieldType.Json;
+            case "unsupported":
+                return AtomicFieldType.Unsupported;
         }
     }
     isIntrinsic() {

package/dist/model/malloy_query.js

@@ -519,6 +519,8 @@ class QueryFieldBoolean extends QueryAtomicField {
 }
 class QueryFieldJSON extends QueryAtomicField {
 }
+class QueryFieldUnsupported extends QueryAtomicField {
+}
 // in a query a struct can be referenced.  The struct will
 //  emit the primary key field in the actual result set and
 //  will include the StructDef as a foreign key join in the output
@@ -1638,6 +1640,9 @@ class QueryQuery extends QueryField {
                                 location
                             });
                             break;
+                        case "unsupported":
+                            fields.push({ ...fi.f.fieldDef, resultMetadata, location });
+                            break;
                         default:
                             throw new Error(`unknown Field Type in query ${JSON.stringify(fi.f.fieldDef)}`);
                     }
@@ -2791,6 +2796,8 @@ class QueryStruct extends QueryNode {
                 return new QueryFieldBoolean(field, this);
             case "json":
                 return new QueryFieldJSON(field, this);
+            case "unsupported":
+                return new QueryFieldUnsupported(field, this);
             // case "reduce":
             // case "project":
             // case "index":

package/dist/model/malloy_types.d.ts

@@ -241,7 +241,7 @@ declare type HasExpression = FieldDef & JustExpression;
 export declare function hasExpression(f: FieldDef): f is HasExpression;
 export declare type TimeFieldType = "date" | "timestamp";
 export declare function isTimeFieldType(s: string): s is TimeFieldType;
-export declare type AtomicFieldType = "string" | "number" | TimeFieldType | "boolean" | "json";
+export declare type AtomicFieldType = "string" | "number" | TimeFieldType | "boolean" | "unsupported" | "json";
 export declare function isAtomicFieldType(s: string): s is AtomicFieldType;
 /** All scalars can have an optional expression */
 export interface FieldAtomicDef extends NamedObject, Expression, ResultMetadata {
@@ -267,6 +267,11 @@ export interface FieldBooleanDef extends FieldAtomicDef {
 export interface FieldJSONDef extends FieldAtomicDef {
     type: "json";
 }
+/** Scalar unsupported Field */
+export interface FieldUnsupportedDef extends FieldAtomicDef {
+    type: "unsupported";
+    rawType?: string;
+}
 export declare type DateUnit = "day" | "week" | "month" | "quarter" | "year";
 export declare function isDateUnit(str: string): str is DateUnit;
 export declare type TimestampUnit = DateUnit | "hour" | "minute" | "second";
@@ -450,7 +455,7 @@ export interface SQLBlockStructDef extends StructDef {
 }
 export declare function isSQLBlock(sd: StructDef): sd is SQLBlockStructDef;
 /** any of the different field types */
-export declare type FieldTypeDef = FieldStringDef | FieldDateDef | FieldTimestampDef | FieldNumberDef | FieldBooleanDef | FieldJSONDef;
+export declare type FieldTypeDef = FieldStringDef | FieldDateDef | FieldTimestampDef | FieldNumberDef | FieldBooleanDef | FieldJSONDef | FieldUnsupportedDef;
 export declare function isFieldTypeDef(f: FieldDef): f is FieldTypeDef;
 export declare function isFieldTimeBased(f: FieldDef): f is FieldTimestampDef | FieldDateDef;
 export declare function isFieldStructDef(f: FieldDef): f is StructDef;

package/dist/model/malloy_types.js

@@ -197,7 +197,15 @@ function isTimeFieldType(s) {
 }
 exports.isTimeFieldType = isTimeFieldType;
 function isAtomicFieldType(s) {
-    return ["string", "number", "date", "timestamp", "boolean", "json"].includes(s);
+    return [
+        "string",
+        "number",
+        "date",
+        "timestamp",
+        "boolean",
+        "json",
+        "unsupported"
+    ].includes(s);
 }
 exports.isAtomicFieldType = isAtomicFieldType;
 // this field definition represents something in the database.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.23",
+  "version": "0.0.24-dev230215185525",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",