@malloydata/malloy 0.0.154 → 0.0.155-dev240722212948

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

@@ -37,7 +37,7 @@ class ExprCast extends expression_def_1.ExpressionDef {
     getExpression(fs) {
         var _a, _b, _c;
         const expr = this.expr.getExpression(fs);
-        let dataType = 'unsupported';
+        let dataType = 'sql native';
         if (typeof this.castType === 'string') {
             dataType = this.castType;
         }
@@ -48,7 +48,7 @@ class ExprCast extends expression_def_1.ExpressionDef {
                     // TODO theoretically `sqlTypeToMalloyType` can get number subtypes,
                     // but `TypeDesc` does not support them.
                     dataType =
-                        (_c = (_b = (_a = fs.dialectObj()) === null || _a === void 0 ? void 0 : _a.sqlTypeToMalloyType(this.castType.raw)) === null || _b === void 0 ? void 0 : _b.type) !== null && _c !== void 0 ? _c : 'unsupported';
+                        (_c = (_b = (_a = fs.dialectObj()) === null || _a === void 0 ? void 0 : _a.sqlTypeToMalloyType(this.castType.raw)) === null || _b === void 0 ? void 0 : _b.type) !== null && _c !== void 0 ? _c : 'sql native';
                 }
                 else {
                     this.log(`Cast type \`${this.castType.raw}\` is invalid for ${dialect.name} dialect`);

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

@@ -68,7 +68,9 @@ class ExpressionDef extends malloy_element_1.MalloyElement {
      */
     typeCheck(eNode, eVal) {
         if (eVal.dataType !== 'error' && !fragtype_utils_1.FT.in(eVal, this.legalChildTypes)) {
-            eNode.log(`'${this.elementType}' Can't use type ${fragtype_utils_1.FT.inspect(eVal)}`);
+            eNode.log(eVal.dataType === 'sql native'
+                ? `'${this.elementType}' Can't be used with unsupported SQL native type '${eVal.rawType}'[unsupported-sql-native-type-not-allowed-in-expression]`
+                : `'${this.elementType}' Can't use type ${fragtype_utils_1.FT.inspect(eVal)}`);
             return false;
         }
         return true;
@@ -248,7 +250,7 @@ function equality(fs, left, op, right) {
     if (err)
         return err;
     // Unsupported types can be compare with null
-    const checkUnsupport = lhs.dataType === 'unsupported' || rhs.dataType === 'unsupported';
+    const checkUnsupport = lhs.dataType === 'sql native' || rhs.dataType === 'sql native';
     if (checkUnsupport) {
         const oneNull = lhs.dataType === 'null' || rhs.dataType === 'null';
         const rawMatch = lhs.rawType && lhs.rawType === rhs.rawType;
@@ -407,7 +409,7 @@ function applyBinary(fs, left, op, right) {
         const denom = right.getExpression(fs);
         const noGo = unsupportError(left, num, right, denom);
         if (noGo) {
-            left.log('Cannot operate with unsupported type');
+            left.log(`Cannot use '${op}' with sql native type`);
             return noGo;
         }
         const err = errorCascade('number', num, denom);
@@ -459,12 +461,12 @@ function unsupportError(l, lhs, r, rhs) {
         value: ["'unsupported operation'"],
         evalSpace: (0, malloy_types_1.mergeEvalSpaces)(lhs.evalSpace, rhs.evalSpace),
     };
-    if (lhs.dataType === 'unsupported') {
-        l.log('Unsupported type not allowed in expression');
+    if (lhs.dataType === 'sql native') {
+        l.log(`Unsupported SQL native type '${lhs.rawType}' not allowed in expression[unsupported-sql-native-type-not-allowed-in-expression]`);
         return { ...ret, dataType: rhs.dataType };
     }
-    if (rhs.dataType === 'unsupported') {
-        r.log('Unsupported type not allowed in expression');
+    if (rhs.dataType === 'sql native') {
+        r.log(`Unsupported SQL native type '${rhs.rawType}' not allowed in expression[unsupported-sql-native-type-not-allowed-in-expression]`);
         return ret;
     }
     return undefined;

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

@@ -39,8 +39,8 @@ 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' &&
+        if (ref.dataType === 'sql native' &&
+            def.type === 'sql native' &&
             def.rawType) {
             ref.rawType = def.rawType;
         }

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

@@ -863,24 +863,24 @@ describe('expressions', () => {
         expect((0, test_translator_1.expr) `${name} = NULL`).toTranslate();
     });
 });
-describe('unspported fields in schema', () => {
-    test('unsupported reference in result allowed', () => {
+describe('sql native fields in schema', () => {
+    test('sql native reference in result allowed', () => {
         const uModel = new test_translator_1.TestTranslator('run: a->{ group_by: aun }');
         expect(uModel).toTranslate();
     });
-    test('unsupported reference can be compared to NULL', () => {
+    test('sql native reference can be compared to NULL', () => {
         const uModel = new test_translator_1.TestTranslator('run: a->{ where: aun != NULL; select: * }');
         expect(uModel).toTranslate();
     });
     test('flag unsupported equality', () => {
         // because we don't know if the two unsupported types are comparable
         const uModel = new test_translator_1.TestTranslator('run: ab->{ where: aun = b.aun  select: * }');
-        expect(uModel).translationToFailWith('Unsupported type not allowed in expression');
+        expect(uModel).translationToFailWith("Unsupported SQL native type 'undefined' not allowed in expression");
     });
     test('flag unsupported compare', () => {
         // because we don't know if the two unsupported types are comparable
         const uModel = new test_translator_1.TestTranslator('run: ab->{ where: aun > b.aun  select: * }');
-        expect(uModel).translationToFailWith('Unsupported type not allowed in expression');
+        expect(uModel).translationToFailWith("Unsupported SQL native type 'undefined' not allowed in expression");
     });
     test('allow unsupported equality when raw types match', () => {
         const uModel = new test_translator_1.TestTranslator('run: ab->{ where: aweird = b.aweird  select: * }');
@@ -888,7 +888,7 @@ describe('unspported fields in schema', () => {
     });
     test('flag not applied to unsupported', () => {
         const uModel = new test_translator_1.TestTranslator('source: x is a extend { dimension: notUn is not aun }');
-        expect(uModel).translationToFailWith("'not' Can't use type unsupported");
+        expect(uModel).translationToFailWith("'not' Can't be used with unsupported SQL native type 'undefined'");
     });
     test('allow unsupported to be cast', () => {
         const uModel = new test_translator_1.TestTranslator('source: x is a extend { dimension: notUn is aun::string }');

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

@@ -94,7 +94,7 @@ describe('structdef comprehension', () => {
     test('import unsupported field', () => {
         const field = {
             name: 't',
-            type: 'unsupported',
+            type: 'sql native',
         };
         const struct = mkStructDef(field);
         const space = new static_space_1.StaticSpace(struct);

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

@@ -49,8 +49,8 @@ const mockSchema = {
             { type: 'date', name: 'ad' },
             { type: 'boolean', name: 'abool' },
             { type: 'timestamp', name: 'ats' },
-            { type: 'unsupported', name: 'aun' },
-            { type: 'unsupported', name: 'aweird', rawType: 'weird' },
+            { type: 'sql native', name: 'aun' },
+            { type: 'sql native', name: 'aweird', rawType: 'weird' },
             {
                 type: 'struct',
                 name: 'astruct',

package/dist/malloy.d.ts

@@ -2,7 +2,7 @@
 import { RunSQLOptions } from './run_sql_options';
 import { DocumentCompletion as DocumentCompletionDefinition, DocumentSymbol as DocumentSymbolDefinition, LogMessage, MalloyTranslator } from './lang';
 import { DocumentHelpContext } from './lang/parse-tree-walkers/document-help-context-walker';
-import { CompiledQuery, DocumentLocation, DocumentReference, FieldBooleanDef, FieldDateDef, FieldJSONDef, FieldNumberDef, FieldStringDef, FieldTimestampDef, FieldTypeDef, FilterExpression, Query as InternalQuery, ModelDef, DocumentPosition as ModelDocumentPosition, NamedQuery, QueryData, QueryDataRow, QueryResult, SQLBlock, SQLBlockSource, SQLBlockStructDef, SearchIndexResult, SearchValueMapResult, StructDef, TurtleDef, FieldUnsupportedDef, QueryRunStats, ImportLocation, Annotation } from './model';
+import { CompiledQuery, DocumentLocation, DocumentReference, FieldBooleanDef, FieldDateDef, FieldJSONDef, FieldNumberDef, FieldStringDef, FieldTimestampDef, FieldTypeDef, FilterExpression, Query as InternalQuery, ModelDef, DocumentPosition as ModelDocumentPosition, NamedQuery, QueryData, QueryDataRow, QueryResult, SQLBlock, SQLBlockSource, SQLBlockStructDef, SearchIndexResult, SearchValueMapResult, StructDef, TurtleDef, FeldNativeUnsupportedDef, QueryRunStats, ImportLocation, Annotation } from './model';
 import { Connection, InfoConnection, LookupConnection, ModelString, ModelURL, QueryString, QueryURL, URLReader } from './runtime_types';
 import { Tag, TagParse, TagParseSpec, Taggable } from './tags';
 import { Dialect } from './dialect';
@@ -565,7 +565,7 @@ export declare enum AtomicFieldType {
     Date = "date",
     Timestamp = "timestamp",
     Json = "json",
-    Unsupported = "unsupported",
+    NativeUnsupported = "sql native",
     Error = "error"
 }
 export declare class AtomicField extends Entity implements Taggable {
@@ -641,7 +641,7 @@ export declare class JSONField extends AtomicField {
 }
 export declare class UnsupportedField extends AtomicField {
     private fieldUnsupportedDef;
-    constructor(fieldUnsupportedDef: FieldUnsupportedDef, parent: Explore, source?: AtomicField);
+    constructor(fieldUnsupportedDef: FeldNativeUnsupportedDef, parent: Explore, source?: AtomicField);
     get rawType(): string | undefined;
 }
 export declare class StringField extends AtomicField {

package/dist/malloy.js

@@ -1025,7 +1025,7 @@ class Explore extends Entity {
                     else if (fieldDef.type === 'json') {
                         return [name, new JSONField(fieldDef, this, sourceField)];
                     }
-                    else if (fieldDef.type === 'unsupported') {
+                    else if (fieldDef.type === 'sql native') {
                         return [name, new UnsupportedField(fieldDef, this, sourceField)];
                     }
                 }
@@ -1152,7 +1152,7 @@ var AtomicFieldType;
     AtomicFieldType["Date"] = "date";
     AtomicFieldType["Timestamp"] = "timestamp";
     AtomicFieldType["Json"] = "json";
-    AtomicFieldType["Unsupported"] = "unsupported";
+    AtomicFieldType["NativeUnsupported"] = "sql native";
     AtomicFieldType["Error"] = "error";
 })(AtomicFieldType || (exports.AtomicFieldType = AtomicFieldType = {}));
 class AtomicField extends Entity {
@@ -1175,8 +1175,8 @@ class AtomicField extends Entity {
                 return AtomicFieldType.Number;
             case 'json':
                 return AtomicFieldType.Json;
-            case 'unsupported':
-                return AtomicFieldType.Unsupported;
+            case 'sql native':
+                return AtomicFieldType.NativeUnsupported;
             case 'error':
                 return AtomicFieldType.Error;
         }

package/dist/model/malloy_query.js

@@ -1928,7 +1928,7 @@ class QueryQuery extends QueryField {
                                 annotation,
                             });
                             break;
-                        case 'unsupported':
+                        case 'sql native':
                             fields.push({ ...fi.f.fieldDef, resultMetadata, location });
                             break;
                         default:
@@ -3148,7 +3148,7 @@ class QueryStruct extends QueryNode {
                 return new QueryFieldBoolean(field, this);
             case 'json':
                 return new QueryFieldJSON(field, this);
-            case 'unsupported':
+            case 'sql native':
                 return new QueryFieldUnsupported(field, this);
             // case "reduce":
             // case "project":

package/dist/model/malloy_types.d.ts

@@ -298,7 +298,7 @@ export declare function hasExpression(f: FieldDef): f is HasExpression;
 export type TimeFieldType = 'date' | 'timestamp';
 export declare function isTimeFieldType(s: string): s is TimeFieldType;
 export type CastType = 'string' | 'number' | TimeFieldType | 'boolean' | 'json';
-export type AtomicFieldType = CastType | 'unsupported' | 'error';
+export type AtomicFieldType = CastType | 'sql native' | 'error';
 export declare function isAtomicFieldType(s: string): s is AtomicFieldType;
 export declare function isCastType(s: string): s is CastType;
 /**
@@ -342,13 +342,13 @@ export interface FieldJSONTypeDef {
 export interface FieldJSONDef extends FieldAtomicDef, FieldJSONTypeDef {
     type: 'json';
 }
-export interface FieldUnsupportedTypeDef {
-    type: 'unsupported';
+export interface FieldNativeUnsupportedTypeDef {
+    type: 'sql native';
     rawType?: string;
 }
 /** Scalar unsupported Field */
-export interface FieldUnsupportedDef extends FieldAtomicDef, FieldUnsupportedTypeDef {
-    type: 'unsupported';
+export interface FeldNativeUnsupportedDef extends FieldAtomicDef, FieldNativeUnsupportedTypeDef {
+    type: 'sql native';
 }
 export interface FieldErrorTypeDef {
     type: 'error';
@@ -628,8 +628,8 @@ export interface SQLBlockStructDef extends StructDef {
 }
 export declare function isSQLBlockStruct(sd: StructDef): sd is SQLBlockStructDef;
 /** any of the different field types */
-export type FieldTypeDef = FieldStringDef | FieldDateDef | FieldTimestampDef | FieldNumberDef | FieldBooleanDef | FieldJSONDef | FieldUnsupportedDef | FieldErrorDef;
-export type FieldAtomicTypeDef = FieldStringTypeDef | FieldDateTypeDef | FieldTimestampTypeDef | FieldNumberTypeDef | FieldBooleanTypeDef | FieldJSONTypeDef | FieldUnsupportedTypeDef | FieldErrorTypeDef;
+export type FieldTypeDef = FieldStringDef | FieldDateDef | FieldTimestampDef | FieldNumberDef | FieldBooleanDef | FieldJSONDef | FeldNativeUnsupportedDef | FieldErrorDef;
+export type FieldAtomicTypeDef = FieldStringTypeDef | FieldDateTypeDef | FieldTimestampTypeDef | FieldNumberTypeDef | FieldBooleanTypeDef | FieldJSONTypeDef | FieldNativeUnsupportedTypeDef | FieldErrorTypeDef;
 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

@@ -220,7 +220,7 @@ function isAtomicFieldType(s) {
         'timestamp',
         'boolean',
         'json',
-        'unsupported',
+        'sql native',
         'error',
     ].includes(s);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.154",
+  "version": "0.0.155-dev240722212948",
   "license": "MIT",
   "exports": {
     ".": "./dist/index.js",