Quantities and date arithmetic

.github/workflows/pre-release.yml

@@ -0,0 +1,45 @@
+# This workflow creates a pre-release Docker image.
+
+name: Deploy pre-release Docker image
+
+on:
+  push:
+    branches:
+      - 'release/*'
+
+jobs:
+  deploy-docker:
+    name: Docker Hub
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+        with:
+          # This is required so that git-commit-id-plugin can find the latest tag.
+          fetch-depth: 0
+      - name: Set up JDK
+        uses: actions/setup-java@v2
+        with:
+          java-version: 11
+          distribution: 'zulu'
+      - name: Cache local Maven repository
+        uses: actions/cache@v2
+        with:
+          path: ~/.m2/repository
+          key: ${{ runner.os }}-maven-${{ hashFiles('**/pom.xml') }}
+          restore-keys: |
+            ${{ runner.os }}-maven-
+      - name: Login to Docker Hub
+        uses: docker/login-action@v1
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+      - name: Run the deploy goal with Maven
+        run: |
+          TAG=$(echo '${{ github.ref }}' | sed 's/refs\/heads\/release\///')
+          mvn --batch-mode deploy \
+          -pl fhir-server -am \
+          -PdockerPreRelease \
+          -Dpathling.fhirServerDockerTag=$TAG \
+          -DskipTests -DskipScalaDocs
+        timeout-minutes: 30

encoders/pom.xml

@@ -20,7 +20,7 @@
   <parent>
     <groupId>au.csiro.pathling</groupId>
     <artifactId>pathling</artifactId>
-    <version>5.4.0</version>
+    <version>6.0.0-SNAPSHOT</version>
   </parent>
   <artifactId>encoders</artifactId>
   <packaging>jar</packaging>
@@ -96,6 +96,13 @@
       <scope>provided</scope>
     </dependency>
 
+    <!-- UCUM -->
+    <dependency>
+      <groupId>au.csiro.pathling</groupId>
+      <artifactId>ucum</artifactId>
+      <version>1.0.4-SNAPSHOT</version>
+    </dependency>
+
     <!-- Logging -->
     <dependency>
       <artifactId>logback-classic</artifactId>

encoders/src/main/java/au/csiro/pathling/encoders/terminology/ucum/Ucum.java

@@ -0,0 +1,115 @@
+/*
+ * This is a modified version of the Bunsen library, originally published at
+ * https://github.com/cerner/bunsen.
+ *
+ * Bunsen is copyright 2017 Cerner Innovation, Inc., and is licensed under
+ * the Apache License, version 2.0 (http://www.apache.org/licenses/LICENSE-2.0).
+ *
+ * These modifications are copyright © 2018-2022, Commonwealth Scientific
+ * and Industrial Research Organisation (CSIRO) ABN 41 687 119 230. Licensed
+ * under the CSIRO Open Source Software Licence Agreement.
+ *
+ */
+
+package au.csiro.pathling.encoders.terminology.ucum;
+
+import au.csiro.pathling.encoders.datatypes.DecimalCustomCoder;
+import java.io.InputStream;
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import au.csiro.pathling.sql.types.FlexiDecimal;
+import org.fhir.ucum.Decimal;
+import org.fhir.ucum.Pair;
+import org.fhir.ucum.UcumEssenceService;
+import org.fhir.ucum.UcumException;
+import org.fhir.ucum.UcumService;
+import org.hl7.fhir.r4.model.DecimalType;
+
+/**
+ * Makes UCUM services available to the rest of the application.
+ *
+ * @author John Grimes
+ */
+public class Ucum {
+
+  public static final String NO_UNIT_CODE = "1";
+
+  public static final String SYSTEM_URI = "http://unitsofmeasure.org";
+
+  private static final UcumService service;
+
+  static {
+    final InputStream essenceStream = Ucum.class.getClassLoader()
+        .getResourceAsStream("tx/ucum-essence.xml");
+    try {
+      service = new UcumEssenceService(essenceStream);
+    } catch (final UcumException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  @Nonnull
+  public static UcumService service() throws UcumException {
+    return service;
+  }
+
+  @Nullable
+  public static BigDecimal getCanonicalValue(@Nullable final BigDecimal value,
+      @Nullable final String code) {
+    try {
+      @Nullable final Pair result = getCanonicalForm(value, code);
+      if (result == null) {
+        return null;
+      }
+      @Nullable final Decimal decimalValue = result.getValue();
+      if (decimalValue == null) {
+        return null;
+      }
+      @Nullable final String stringValue = decimalValue.asDecimal();
+      if (stringValue == null) {
+        return null;
+      }
+      return new BigDecimal(stringValue);
+    } catch (final UcumException e) {
+      return null;
+    }
+  }
+
+  @Nullable
+  public static String getCanonicalCode(@Nullable final BigDecimal value,
+      @Nullable final String code) {
+    try {
+      @Nullable final Pair result = getCanonicalForm(value, code);
+      if (result == null) {
+        return null;
+      }
+      return result.getCode();
+    } catch (final UcumException e) {
+      return null;
+    }
+  }
+
+  @Nullable
+  private static Pair getCanonicalForm(final @Nullable BigDecimal value,
+      final @Nullable String code)
+      throws UcumException {
+    if (value == null || code == null) {
+      return null;
+    }
+    final Decimal decimalValue = new Decimal(value.toPlainString());
+    return adjustNoUnitCode(service.getCanonicalForm(new Pair(decimalValue, code)));
+  }
+
+  @Nullable
+  private static Pair adjustNoUnitCode(@Nullable Pair pair) {
+    if (pair == null) {
+      return null;
+    }
+    return (pair.getCode() != null && pair.getCode().isEmpty())
+           ? new Pair(pair.getValue(), NO_UNIT_CODE)
+           : pair;
+  }
+
+}

encoders/src/main/java/au/csiro/pathling/sql/types/FlexiDecimal.java

@@ -0,0 +1,208 @@
+package au.csiro.pathling.sql.types;
+
+import au.csiro.pathling.encoders.datatypes.DecimalCustomCoder;
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import org.apache.spark.sql.Column;
+import org.apache.spark.sql.Row;
+import org.apache.spark.sql.RowFactory;
+import org.apache.spark.sql.api.java.UDF1;
+import org.apache.spark.sql.api.java.UDF2;
+import org.apache.spark.sql.expressions.UserDefinedFunction;
+import org.apache.spark.sql.functions;
+import org.apache.spark.sql.types.DataType;
+import org.apache.spark.sql.types.DataTypes;
+import org.apache.spark.sql.types.Decimal;
+import org.apache.spark.sql.types.Metadata;
+import org.apache.spark.sql.types.MetadataBuilder;
+import org.apache.spark.sql.types.StructField;
+import org.apache.spark.sql.types.StructType;
+
+/**
+ * Implementation of flexible decimal type represented as the unscaled value with up to 38 digits
+ * and the scale.
+ *
+ * @author Piotr Szul
+ */
+public class FlexiDecimal {
+
+  /**
+   * The maximum precision (the number of significant digits).
+   */
+  public static final int MAX_PRECISION = 38;
+  /**
+   * The SQL type for the unscaled value.
+   */
+  public static final DataType DECIMAL_TYPE = DataTypes.createDecimalType(MAX_PRECISION, 0);
+
+  @Nonnull
+  private static StructType createFlexibleDecimalType() {
+    final Metadata metadata = new MetadataBuilder().build();
+    final StructField value = new StructField("value", DECIMAL_TYPE, true,
+        metadata);
+    final StructField scale = new StructField("scale", DataTypes.IntegerType, true, metadata);
+    return new StructType(new StructField[]{value, scale});
+  }
+
+  /**
+   * The SQL (struct) type for flexible decimal.
+   */
+  @Nonnull
+  public static DataType DATA_TYPE = createFlexibleDecimalType();
+
+  @Nonnull
+  private static UserDefinedFunction toBooleanUdf(
+      @Nonnull final UDF2<BigDecimal, BigDecimal, Boolean> method) {
+    final UDF2<Row, Row, Boolean> f = (left, right) -> {
+      final BigDecimal leftValue = fromValue(left);
+      final BigDecimal rightValue = fromValue(right);
+      //noinspection ReturnOfNull
+      return (leftValue == null || rightValue == null)
+             ? null
+             : method.call(leftValue, rightValue);
+    };
+    return functions.udf(f, DataTypes.BooleanType);
+  }
+
+  @Nonnull
+  private static UDF2<Row, Row, Row> wrapBigDecimal2(
+      @Nonnull final UDF2<BigDecimal, BigDecimal, BigDecimal> method) {
+    //noinspection ReturnOfNull
+    return (left, right) ->
+        (left == null || right == null)
+        ? null
+        : toValue(method.call(fromValue(left), fromValue(right)));
+  }
+
+  @Nonnull
+  private static UserDefinedFunction toBigDecimalUdf(
+      @Nonnull final UDF2<BigDecimal, BigDecimal, BigDecimal> method) {
+    return functions.udf(wrapBigDecimal2(method), DATA_TYPE);
+  }
+
+  /**
+   * Decodes a flexible decimal from the Row
+   *
+   * @param row the row to decode
+   * @return the BigDecimal representation of the row
+   */
+  @Nullable
+  public static BigDecimal fromValue(@Nullable final Row row) {
+    return row != null && !row.isNullAt(0)
+           ? row.getDecimal(0).movePointLeft(row.getInt(1))
+           : null;
+  }
+
+  /**
+   * Encodes a flexible decimal into a Row
+   *
+   * @param decimal the decimal to encode
+   * @return the Row representation of the decimal
+   */
+  @Nullable
+  public static Row toValue(@Nullable final BigDecimal decimal) {
+    final Object[] fieldValues = toArrayValue(decimal);
+    return fieldValues != null
+           ? RowFactory.create(fieldValues)
+           : null;
+  }
+
+  @Nullable
+  private static Object[] toArrayValue(@Nullable final BigDecimal decimal) {
+    final BigDecimal normalizedValue = normalize(decimal);
+    return normalizedValue != null
+           ? new Object[]{Decimal.apply(normalizedValue.unscaledValue()), normalizedValue.scale()}
+           : null;
+  }
+
+  @Nullable
+  public static BigDecimal normalize(@Nullable final BigDecimal decimal) {
+    if (decimal == null) {
+      return null;
+    } else {
+      final BigDecimal adjustedValue = decimal.scale() < 0
+                                       ? decimal.setScale(0, RoundingMode.UNNECESSARY)
+                                       : decimal;
+      // This may be may have too many digits
+      if (adjustedValue.precision() > MAX_PRECISION) {
+        // we need to adjust the scale to fit into the desired precision
+        final int desiredScale =
+            adjustedValue.scale() - (adjustedValue.precision() - MAX_PRECISION);
+        if (desiredScale >= 0) {
+          return adjustedValue.setScale(desiredScale, RoundingMode.HALF_UP);
+        } else {
+          return null;
+        }
+      } else {
+        return adjustedValue;
+      }
+    }
+  }
+
+  private static final UserDefinedFunction EQUALS_UDF = toBooleanUdf((l, r) -> l.compareTo(r) == 0);
+  private static final UserDefinedFunction LT_UDF = toBooleanUdf((l, r) -> l.compareTo(r) < 0);
+  private static final UserDefinedFunction LTE_UDF = toBooleanUdf((l, r) -> l.compareTo(r) <= 0);
+  private static final UserDefinedFunction GT_UDF = toBooleanUdf((l, r) -> l.compareTo(r) > 0);
+  private static final UserDefinedFunction GTE_UDF = toBooleanUdf((l, r) -> l.compareTo(r) >= 0);
+
+  private static final UserDefinedFunction PLUS_UDF = toBigDecimalUdf(BigDecimal::add);
+  private static final UserDefinedFunction MULTIPLY_UDF = toBigDecimalUdf(BigDecimal::multiply);
+  private static final UserDefinedFunction MINUS_UDF = toBigDecimalUdf(BigDecimal::subtract);
+  private static final UserDefinedFunction DIVIDE_UDF = toBigDecimalUdf(BigDecimal::divide);
+
+  private static final UserDefinedFunction TO_DECIMAL = functions.udf(
+      (UDF1<Row, BigDecimal>) FlexiDecimal::fromValue,
+      DecimalCustomCoder.decimalType());
+
+  @Nonnull
+  public static Column equals(@Nonnull final Column left, @Nonnull final Column right) {
+    return EQUALS_UDF.apply(left, right);
+  }
+
+  @Nonnull
+  public static Column lt(@Nonnull final Column left, @Nonnull final Column right) {
+    return LT_UDF.apply(left, right);
+  }
+
+  @Nonnull
+  public static Column lte(@Nonnull final Column left, @Nonnull final Column right) {
+    return LTE_UDF.apply(left, right);
+  }
+
+  @Nonnull
+  public static Column gt(@Nonnull final Column left, @Nonnull final Column right) {
+    return GT_UDF.apply(left, right);
+  }
+
+  @Nonnull
+  public static Column gte(@Nonnull final Column left, @Nonnull final Column right) {
+    return GTE_UDF.apply(left, right);
+  }
+
+  @Nonnull
+  public static Column plus(@Nonnull final Column left, @Nonnull final Column right) {
+    return PLUS_UDF.apply(left, right);
+  }
+
+  @Nonnull
+  public static Column multiply(@Nonnull final Column left, @Nonnull final Column right) {
+    return MULTIPLY_UDF.apply(left, right);
+  }
+
+  @Nonnull
+  public static Column minus(@Nonnull final Column left, @Nonnull final Column right) {
+    return MINUS_UDF.apply(left, right);
+  }
+
+  @Nonnull
+  public static Column divide(@Nonnull final Column left, @Nonnull final Column right) {
+    return DIVIDE_UDF.apply(left, right);
+  }
+
+  @Nonnull
+  public static Column toDecimal(@Nonnull final Column flexiDecimal) {
+    return TO_DECIMAL.apply(flexiDecimal);
+  }
+}