CQL Long (#363)

- Add CQL Long support using JavaScript BigInt
- Extend arithmetic, comparison, aggregate, list, and interval operations to handle Long values and Interval<Long>
- Improve overflow/underflow handling with type-aware min/max, successor, predecessor, sum, product, and power behavior
- Add shared ELM type constants and update type-specifier handling to reduce hard-coded type strings.
- Expand unit/spec tests for Long behavior and remove now-supported Long cases from the skip list.
---------

Co-authored-by: lmd59 <lmd59@cornell.edu>

Author: cmoesel

README.md

@@ -42,8 +42,6 @@ Implementors should be aware of the following limitations and gaps in `cql-execu
   * Issues typically associated with floating point arithmetic
   * Decimals without a decimal portion (e.g., `2.0`) may be treated as CQL `Integer`s
 * The following STU (non-normative) features introduced in CQL 1.5 are not yet supported:
-  * `Long` datatype
-  * Fluent functions
   * Retrieve search paths
   * Retrieve includes
 * In addition the following features defined prior to CQL 1.5 are also not yet supported:

examples/browser/cql4browsers.js

@@ -1,5 +1,6 @@
 import * as DT from './datatypes/datatypes';
 import { DataProvider, NamedTypeSpecifier, PatientObject, RecordObject } from './types';
+import { ELM_NAMED_TYPE_SPECIFIER } from './util/elmTypes';
 
 export class Record implements RecordObject {
   json: any;
@@ -20,13 +21,13 @@ export class Record implements RecordObject {
     return [
       {
         name: `{https://github.com/cqframework/cql-execution/simple}${this.json.recordType}`,
-        type: 'NamedTypeSpecifier'
+        type: ELM_NAMED_TYPE_SPECIFIER
       },
       {
         name: '{https://github.com/cqframework/cql-execution/simple}Record',
-        type: 'NamedTypeSpecifier'
+        type: ELM_NAMED_TYPE_SPECIFIER
       },
-      { name: '{urn:hl7-org:elm-types:r1}Any', type: 'NamedTypeSpecifier' }
+      { name: '{urn:hl7-org:elm-types:r1}Any', type: ELM_NAMED_TYPE_SPECIFIER }
     ];
   }
 

src/cql-patient.ts

@@ -0,0 +1,20 @@
+// By default, BigInt throws a TypeError if you attempt to JSON.stringify it.
+// You can avoid the TypeError by defining a `toJSON()` function for BigInt.
+// We will use the same serialization approach as FHIR uses for integer64: a string.
+// See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt#use_within_json
+// See: https://hl7.org/fhir/R5/json.html#primitive
+
+declare global {
+  interface BigInt {
+    toJSON?(): unknown;
+  }
+}
+
+if (BigInt.prototype.toJSON === undefined) {
+  BigInt.prototype.toJSON = function () {
+    return this.toString();
+  };
+}
+
+// empty export forces typescript to recognize this file as a module
+export {};

src/datatypes/bigint.ts

@@ -1,3 +1,4 @@
+export * from './bigint';
 export * from './logic';
 export * from './clinical';
 export * from './uncertainty';

src/datatypes/datatypes.ts

@@ -10,6 +10,15 @@ import {
   minValueForType
 } from '../util/math';
 import * as cmp from '../util/comparison';
+import {
+  ELM_INTEGER_TYPE,
+  ELM_DECIMAL_TYPE,
+  ELM_LONG_TYPE,
+  ELM_TIME_TYPE,
+  ELM_DATE_TYPE,
+  ELM_DATETIME_TYPE,
+  ELM_QUANTITY_TYPE
+} from '../util/elmTypes';
 
 export class Interval {
   constructor(
@@ -40,17 +49,17 @@ export class Interval {
     const point = this.low != null ? this.low : this.high;
     if (point != null) {
       if (typeof point === 'number') {
-        pointType = Number.isInteger(point)
-          ? '{urn:hl7-org:elm-types:r1}Integer'
-          : '{urn:hl7-org:elm-types:r1}Decimal';
+        pointType = Number.isInteger(point) ? ELM_INTEGER_TYPE : ELM_DECIMAL_TYPE;
+      } else if (typeof point === 'bigint') {
+        pointType = ELM_LONG_TYPE;
       } else if (point.isTime && point.isTime()) {
-        pointType = '{urn:hl7-org:elm-types:r1}Time';
+        pointType = ELM_TIME_TYPE;
       } else if (point.isDate) {
-        pointType = '{urn:hl7-org:elm-types:r1}Date';
+        pointType = ELM_DATE_TYPE;
       } else if (point.isDateTime) {
-        pointType = '{urn:hl7-org:elm-types:r1}DateTime';
+        pointType = ELM_DATETIME_TYPE;
       } else if (point.isQuantity) {
-        pointType = '{urn:hl7-org:elm-types:r1}Quantity';
+        pointType = ELM_QUANTITY_TYPE;
       }
     }
     if (pointType == null && this.defaultPointType != null) {
@@ -317,7 +326,7 @@ export class Interval {
         !other.highClosed &&
         !this.highClosed)
     ) {
-      if (typeof this.low === 'number') {
+      if (typeof this.low === 'number' || typeof this.low === 'bigint') {
         if (!(this.start() === other.start())) {
           return false;
         }
@@ -331,7 +340,7 @@ export class Interval {
       (this.low == null && other.low != null && this.high != null && other.high != null) ||
       (this.low == null && other.low == null && this.high != null && other.high != null)
     ) {
-      if (typeof this.high === 'number') {
+      if (typeof this.high === 'number' || typeof this.high === 'bigint') {
         if (!(this.end() === other.end())) {
           return false;
         }
@@ -366,7 +375,7 @@ export class Interval {
       return false;
     }
 
-    if (typeof this.low === 'number') {
+    if (typeof this.low === 'number' || typeof this.low === 'bigint') {
       return this.start() === other.start() && this.end() === other.end();
     } else {
       return (
@@ -437,7 +446,7 @@ export class Interval {
           precision
         );
       } else {
-        return cmp.equals(this.toClosed().low, successor(other.toClosed().high));
+        return cmp.equals(this.toClosed().low, successor(other.toClosed().high, other.pointType));
       }
     } catch {
       return false;
@@ -452,7 +461,7 @@ export class Interval {
           precision
         );
       } else {
-        return cmp.equals(this.toClosed().high, predecessor(other.toClosed().low));
+        return cmp.equals(this.toClosed().high, predecessor(other.toClosed().low, other.pointType));
       }
     } catch {
       return false;
@@ -521,20 +530,20 @@ export class Interval {
       if (closed.low.unit !== closed.high.unit) {
         throw new Error('Cannot calculate width of Quantity Interval with different units');
       }
-      const lowValue = closed.low.value;
-      const highValue = closed.high.value;
-      let diff = Math.abs(highValue - lowValue);
+
+      let diff = closed.high.value - closed.low.value;
       diff = Math.round(diff * Math.pow(10, 8)) / Math.pow(10, 8);
       return new Quantity(diff, closed.low.unit);
+    } else if (typeof closed.low === 'bigint') {
+      return closed.high - closed.low;
     } else {
       // TODO: Fix precision to 8 decimals in other places that return numbers
-      const diff = Math.abs(closed.high - closed.low);
+      const diff = closed.high - closed.low;
       return Math.round(diff * Math.pow(10, 8)) / Math.pow(10, 8);
     }
   }
 
   size() {
-    const pointSize = this.getPointSize();
     if (
       (this.low != null && (this.low.isDateTime || this.low.isDate)) ||
       (this.high != null && (this.high.isDateTime || this.high.isDate))
@@ -548,17 +557,21 @@ export class Interval {
       (closed.high != null && closed.high.isUncertainty)
     ) {
       return null;
-    } else if (closed.low.isQuantity) {
+    }
+
+    const pointSize = this.getPointSize();
+    if (closed.low.isQuantity) {
       if (closed.low.unit !== closed.high.unit) {
         throw new Error('Cannot calculate size of Quantity Interval with different units');
       }
-      const lowValue = closed.low.value;
-      const highValue = closed.high.value;
-      let diff = Math.abs(highValue - lowValue) + pointSize.value;
+
+      let diff = closed.high.value - closed.low.value + pointSize.value;
       diff = Math.round(diff * Math.pow(10, 8)) / Math.pow(10, 8);
       return new Quantity(diff, closed.low.unit);
+    } else if (typeof closed.low === 'bigint') {
+      return closed.high - closed.low + pointSize;
     } else {
-      const diff = Math.abs(closed.high - closed.low) + pointSize.value;
+      const diff = closed.high - closed.low + pointSize;
       return Math.round(diff * Math.pow(10, 8)) / Math.pow(10, 8);
     }
   }
@@ -569,24 +582,20 @@ export class Interval {
       if (this.low.isDateTime || this.low.isDate || this.low.isTime) {
         pointSize = new Quantity(1, this.low.getPrecision());
       } else if (this.low.isQuantity) {
-        pointSize = doSubtraction(successor(this.low), this.low);
+        pointSize = doSubtraction(successor(this.low, this.pointType), this.low);
       } else {
-        pointSize = successor(this.low) - this.low;
+        pointSize = successor(this.low, this.pointType) - this.low;
       }
     } else if (this.high != null) {
       if (this.high.isDateTime || this.high.isDate || this.high.isTime) {
         pointSize = new Quantity(1, this.high.getPrecision());
       } else if (this.high.isQuantity) {
-        pointSize = doSubtraction(successor(this.high), this.high);
+        pointSize = doSubtraction(this.high, predecessor(this.high, this.pointType));
       } else {
-        pointSize = successor(this.high) - this.high;
+        pointSize = this.high - predecessor(this.high, this.pointType);
       }
     } else {
-      throw new Error('Point type of intervals cannot be determined.');
-    }
-
-    if (typeof pointSize === 'number') {
-      pointSize = new Quantity(pointSize, '1');
+      throw new Error('Point type of interval cannot be determined.');
     }
 
     return pointSize;
@@ -602,15 +611,15 @@ export class Interval {
       if (this.lowClosed && this.low == null) {
         low = minValueForType(this.pointType);
       } else if (!this.lowClosed && this.low != null) {
-        low = successor(this.low);
+        low = successor(this.low, this.pointType);
       } else {
         low = this.low;
       }
       let high;
       if (this.highClosed && this.high == null) {
         high = maxValueForType(this.pointType);
       } else if (!this.highClosed && this.high != null) {
-        high = predecessor(this.high);
+        high = predecessor(this.high, this.pointType);
       } else {
         high = this.high;
       }
@@ -639,7 +648,11 @@ function areDateTimes(x: any, y: any) {
 
 function areNumeric(x: any, y: any) {
   return [x, y].every(z => {
-    return typeof z === 'number' || (z != null && z.isUncertainty && typeof z.low === 'number');
+    return (
+      typeof z === 'number' ||
+      typeof z === 'bigint' ||
+      (z != null && z.isUncertainty && (typeof z.low === 'number' || typeof z.low === 'bigint'))
+    );
   });
 }
 

src/datatypes/interval.ts

@@ -1,3 +1,4 @@
+import { ELM_DECIMAL_TYPE } from '../util/elmTypes';
 import { decimalAdjust, isValidDecimal, overflowsOrUnderflows } from '../util/math';
 import {
   checkUnit,
@@ -125,7 +126,7 @@ export class Quantity {
     const resultUnit = getQuotientOfUnits(unit1, unit2);
 
     // Check for invalid unit or value
-    if (resultUnit == null || overflowsOrUnderflows(resultValue)) {
+    if (resultUnit == null || overflowsOrUnderflows(resultValue, ELM_DECIMAL_TYPE)) {
       return null;
     }
     return new Quantity(decimalAdjust('round', resultValue, -8), resultUnit);
@@ -149,7 +150,7 @@ export class Quantity {
     const resultUnit = getProductOfUnits(unit1, unit2);
 
     // Check for invalid unit or value
-    if (resultUnit == null || overflowsOrUnderflows(resultValue)) {
+    if (resultUnit == null || overflowsOrUnderflows(resultValue, ELM_DECIMAL_TYPE)) {
       return null;
     }
     return new Quantity(decimalAdjust('round', resultValue, -8), resultUnit);
@@ -188,7 +189,7 @@ function doScaledAddition(a: any, b: any, scaleForB: any) {
       return null;
     }
     const sum = val1 + val2;
-    if (overflowsOrUnderflows(sum)) {
+    if (overflowsOrUnderflows(sum, ELM_DECIMAL_TYPE)) {
       return null;
     }
     return new Quantity(sum, unit1);

src/datatypes/quantity.ts

@@ -5,6 +5,8 @@ import { Context } from '../runtime/context';
 import { Exception } from '../datatypes/exception';
 import { greaterThan, lessThan } from '../util/comparison';
 import { build } from './builder';
+import { overflowsOrUnderflows } from '../util/math';
+import { ELM_DECIMAL_TYPE } from '../util/elmTypes';
 
 class AggregateExpression extends Expression {
   source: any;
@@ -53,9 +55,10 @@ export class Sum extends AggregateExpression {
     if (hasOnlyQuantities(items)) {
       const values = getValuesFromQuantities(items);
       const sum = values.reduce((x, y) => x + y);
-      return new Quantity(sum, items[0].unit);
+      return overflowsOrUnderflows(sum, ELM_DECIMAL_TYPE) ? null : new Quantity(sum, items[0].unit);
     } else {
-      return items.reduce((x: number, y: number) => x + y);
+      const sum = items.reduce((x: any, y: any) => x + y);
+      return overflowsOrUnderflows(sum, this.resultTypeName) ? null : sum;
     }
   }
 }
@@ -339,9 +342,12 @@ export class Product extends AggregateExpression {
       const values = getValuesFromQuantities(items);
       const product = values.reduce((x, y) => x * y);
       // Units are not multiplied for the geometric product
-      return new Quantity(product, items[0].unit);
+      return overflowsOrUnderflows(product, ELM_DECIMAL_TYPE)
+        ? null
+        : new Quantity(product, items[0].unit);
     } else {
-      return items.reduce((x: number, y: number) => x * y);
+      const product = items.reduce((x: any, y: any) => x * y);
+      return overflowsOrUnderflows(product, this.resultTypeName) ? null : product;
     }
   }
 }