diff --git a/.github/workflows/pre-release.yml b/.github/workflows/pre-release.yml new file mode 100644 index 0000000000..fa686deee0 --- /dev/null +++ b/.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 diff --git a/encoders/pom.xml b/encoders/pom.xml index 7cec9fef30..4e617dd655 100644 --- a/encoders/pom.xml +++ b/encoders/pom.xml @@ -20,7 +20,7 @@ au.csiro.pathling pathling - 5.4.0 + 6.0.0-SNAPSHOT encoders jar @@ -96,6 +96,13 @@ provided + + + au.csiro.pathling + ucum + 1.0.4-SNAPSHOT + + logback-classic diff --git a/encoders/src/main/java/au/csiro/pathling/encoders/terminology/ucum/Ucum.java b/encoders/src/main/java/au/csiro/pathling/encoders/terminology/ucum/Ucum.java new file mode 100644 index 0000000000..8d17d1cfa5 --- /dev/null +++ b/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; + } + +} diff --git a/encoders/src/main/java/au/csiro/pathling/sql/types/FlexiDecimal.java b/encoders/src/main/java/au/csiro/pathling/sql/types/FlexiDecimal.java new file mode 100644 index 0000000000..462a53c2ce --- /dev/null +++ b/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 method) { + final UDF2 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 wrapBigDecimal2( + @Nonnull final UDF2 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 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) 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); + } +} diff --git a/encoders/src/main/resources/tx/ucum-essence.xml b/encoders/src/main/resources/tx/ucum-essence.xml new file mode 100644 index 0000000000..d012996905 --- /dev/null +++ b/encoders/src/main/resources/tx/ucum-essence.xml @@ -0,0 +1,2110 @@ + + + + yotta + Y + 1 × 10 + 24 + + + + zetta + Z + 1 × 10 + 21 + + + + exa + E + 1 × 10 + 18 + + + + peta + P + 1 × 10 + 15 + + + + tera + T + 1 × 10 + 12 + + + + giga + G + 1 × 10 + 9 + + + + mega + M + 1 × 10 + 6 + + + + kilo + k + 1 × 10 + 3 + + + + hecto + h + 1 × 10 + 2 + + + + deka + da + 1 × 10 + 1 + + + + deci + d + 1 × 10 + -1 + + + + centi + c + 1 × 10 + -2 + + + + milli + m + 1 × 10 + -3 + + + + micro + μ + 1 × 10 + -6 + + + + nano + n + 1 × 10 + -9 + + + + pico + p + 1 × 10 + -12 + + + + femto + f + 1 × 10 + -15 + + + + atto + a + 1 × 10 + -18 + + + + zepto + z + 1 × 10 + -21 + + + + yocto + y + 1 × 10 + -24 + + + + meter + m + length + + + second + s + time + + + gram + g + mass + + + radian + rad + plane angle + + + kelvin + K + temperature + + + coulomb + C + electric charge + + + candela + cd + luminous intensity + + + the number ten for arbitrary powers + 10 + number + 10 + + + the number ten for arbitrary powers + 10 + number + 10 + + + the number pi + π + number + π + + + + percent + % + fraction + 1 + + + parts per thousand + ppth + fraction + 1 + + + parts per million + ppm + fraction + 1 + + + parts per billion + ppb + fraction + 1 + + + parts per trillion + pptr + fraction + 1 + + + mole + mol + amount of substance + 6.0221367 + + + steradian + sr + solid angle + 1 + + + hertz + Hz + frequency + 1 + + + newton + N + force + 1 + + + pascal + Pa + pressure + 1 + + + joule + J + energy + 1 + + + watt + W + power + 1 + + + ampère + A + electric current + 1 + + + volt + V + electric potential + 1 + + + farad + F + electric capacitance + 1 + + + ohm + Ω + electric resistance + 1 + + + siemens + S + electric conductance + 1 + + + weber + Wb + magnetic flux + 1 + + + degree Celsius + °C + temperature + + + + + + tesla + T + magnetic flux density + 1 + + + henry + H + inductance + 1 + + + lumen + lm + luminous flux + 1 + + + lux + lx + illuminance + 1 + + + becquerel + Bq + radioactivity + 1 + + + gray + Gy + energy dose + 1 + + + sievert + Sv + dose equivalent + 1 + + + gon + grade + □g + + plane angle + 0.9 + + + degree + ° + plane angle + 2 + + + minute + ' + plane angle + 1 + + + second + '' + plane angle + 1 + + + liter + l + volume + 1 + + + liter + L + volume + 1 + + + are + a + area + 100 + + + minute + min + time + 60 + + + hour + h + time + 60 + + + day + d + time + 24 + + + tropical year + a + t + + time + 365.24219 + + + mean Julian year + a + j + + time + 365.25 + + + mean Gregorian year + a + g + + time + 365.2425 + + + year + a + time + 1 + + + week + wk + time + 7 + + + synodal month + mo + s + + time + 29.53059 + + + mean Julian month + mo + j + + time + 1 + + + mean Gregorian month + mo + g + + time + 1 + + + month + mo + time + 1 + + + tonne + t + mass + 1 × 10 + 3 + + + + bar + bar + pressure + 1 × 10 + 5 + + + + unified atomic mass unit + u + mass + 1.6605402 × 10 + -24 + + + + electronvolt + eV + energy + 1 + + + astronomic unit + AU + length + 149597.870691 + + + parsec + pc + length + 3.085678 × 10 + 16 + + + + velocity of light + + c + + velocity + 299792458 + + + Planck constant + + h + + action + 6.6260755 × 10 + -34 + + + + Boltzmann constant + + k + + (unclassified) + 1.380658 × 10 + -23 + + + + permittivity of vacuum + + ε + 0 + + + + electric permittivity + 8.854187817 × 10 + -12 + + + + permeability of vacuum + + μ + 0 + + + + magnetic permeability + 1 + + + elementary charge + + e + + electric charge + 1.60217733 × 10 + -19 + + + + electron mass + + m + + e + + + + mass + 9.1093897 × 10 + -28 + + + + proton mass + + m + + p + + + + mass + 1.6726231 × 10 + -24 + + + + Newtonian constant of gravitation + + G + + (unclassified) + 6.67259 × 10 + -11 + + + + standard acceleration of free fall + + g + n + + + acceleration + 9.80665 + + + standard atmosphere + atm + pressure + 101325 + + + light-year + l.y. + length + 1 + + + gram-force + gf + force + 1 + + + pound force + lbf + force + 1 + + + Kayser + K + lineic number + 1 + + + Gal + Gal + acceleration + 1 + + + dyne + dyn + force + 1 + + + erg + erg + energy + 1 + + + Poise + P + dynamic viscosity + 1 + + + Biot + Bi + electric current + 10 + + + Stokes + St + kinematic viscosity + 1 + + + Maxwell + Mx + flux of magnetic induction + 1 × 10 + -8 + + + + Gauss + Gs + magnetic flux density + 1 × 10 + -4 + + + + Oersted + Oe + magnetic field intensity + 250 + + + Gilbert + Gb + magnetic tension + 1 + + + stilb + sb + lum. intensity density + 1 + + + Lambert + L + brightness + 1 + + + phot + ph + illuminance + 1 × 10 + -4 + + + + Curie + Ci + radioactivity + 3.7 × 10 + 10 + + + + Roentgen + R + ion dose + 2.58 × 10 + -4 + + + + radiation absorbed dose + RAD + energy dose + 100 + + + radiation equivalent man + REM + dose equivalent + 1 + + + inch + in + length + 2.54 + + + foot + ft + length + 12 + + + yard + yd + length + 3 + + + mile + mi + length + 5280 + + + fathom + fth + depth of water + 6 + + + nautical mile + n.mi + length + 1852 + + + knot + knot + velocity + 1 + + + square inch + area + 1 + + + square foot + area + 1 + + + square yard + area + 1 + + + cubic inch + volume + 1 + + + cubic foot + volume + 1 + + + cubic yard + cu.yd + volume + 1 + + + board foot + volume + 144 + + + cord + volume + 128 + + + mil + mil + length + 1 × 10 + -3 + + + + circular mil + circ.mil + area + 1 + + + hand + hd + height of horses + 4 + + + foot + ft + us + + length + 1200 + + + yard + length + 3 + + + inch + length + 1 + + + rod + length + 16.5 + + + Gunter's chain + Surveyor's chain + length + 4 + + + link for Gunter's chain + length + 1 + + + Ramden's chain + Engineer's chain + length + 100 + + + link for Ramden's chain + length + 1 + + + fathom + length + 6 + + + furlong + length + 40 + + + mile + length + 8 + + + acre + area + 160 + + + square rod + area + 1 + + + square mile + area + 1 + + + section + area + 1 + + + township + area + 36 + + + mil + length + 1 × 10 + -3 + + + + inch + length + 2.539998 + + + foot + length + 12 + + + rod + length + 16.5 + + + Gunter's chain + length + 4 + + + link for Gunter's chain + length + 1 + + + fathom + length + 6 + + + pace + length + 2.5 + + + yard + length + 3 + + + mile + length + 5280 + + + nautical mile + length + 6080 + + + knot + velocity + 1 + + + acre + area + 4840 + + + Queen Anne's wine gallon + fluid volume + 231 + + + barrel + fluid volume + 42 + + + quart + fluid volume + 1 + + + pint + fluid volume + 1 + + + gill + fluid volume + 1 + + + fluid ounce + oz fl + fluid volume + 1 + + + fluid dram + fluid volume + 1 + + + minim + fluid volume + 1 + + + cord + fluid volume + 128 + + + bushel + dry volume + 2150.42 + + + historical winchester gallon + dry volume + 1 + + + peck + dry volume + 1 + + + dry quart + dry volume + 1 + + + dry pint + dry volume + 1 + + + tablespoon + volume + 1 + + + teaspoon + volume + 1 + + + cup + volume + 16 + + + metric fluid ounce + oz fl + fluid volume + 30 + + + metric cup + volume + 240 + + + metric teaspoon + volume + 5 + + + metric tablespoon + volume + 15 + + + gallon + volume + 4.54609 + + + peck + volume + 2 + + + bushel + volume + 4 + + + quart + volume + 1 + + + pint + volume + 1 + + + gill + volume + 1 + + + fluid ounce + volume + 1 + + + fluid dram + volume + 1 + + + minim + volume + 1 + + + grain + mass + 64.79891 + + + pound + lb + mass + 7000 + + + ounce + oz + mass + 1 + + + dram + mass + 1 + + + short hundredweight + U.S. hundredweight + mass + 100 + + + long hunderdweight + British hundredweight + mass + 112 + + + short ton + U.S. ton + mass + 20 + + + long ton + British ton + mass + 20 + + + stone + British stone + mass + 14 + + + pennyweight + mass + 24 + + + ounce + mass + 20 + + + pound + mass + 12 + + + scruple + mass + 20 + + + dram + drachm + mass + 3 + + + ounce + mass + 8 + + + pound + mass + 12 + + + metric ounce + mass + 28 + + + line + length + 1 + + + point + length + 1 + + + pica + length + 12 + + + Printer's point + length + 0.013837 + + + Printer's pica + length + 12 + + + pied + French foot + length + 32.48 + + + pouce + French inch + length + 1 + + + ligne + French line + length + 1 + + + didot + Didot's point + length + 1 + + + cicero + Didot's pica + length + 12 + + + degree Fahrenheit + °F + temperature + + + + + + degree Rankine + °R + temperature + 5 + + + degree Réaumur + °Ré + temperature + + + + + + calorie at 15 °C + cal + 15°C + + energy + 4.18580 + + + calorie at 20 °C + cal + 20°C + + energy + 4.18190 + + + mean calorie + cal + m + + energy + 4.19002 + + + international table calorie + cal + IT + + energy + 4.1868 + + + thermochemical calorie + cal + th + + energy + 4.184 + + + calorie + cal + energy + 1 + + + nutrition label Calories + Cal + energy + 1 + + + British thermal unit at 39 °F + Btu + 39°F + + energy + 1.05967 + + + British thermal unit at 59 °F + Btu + 59°F + + energy + 1.05480 + + + British thermal unit at 60 °F + Btu + 60°F + + energy + 1.05468 + + + mean British thermal unit + Btu + m + + energy + 1.05587 + + + international table British thermal unit + Btu + IT + + energy + 1.05505585262 + + + thermochemical British thermal unit + Btu + th + + energy + 1.054350 + + + British thermal unit + btu + energy + 1 + + + horsepower + power + 550 + + + tex + tex + linear mass density (of textile thread) + 1 + + + Denier + den + linear mass density (of textile thread) + 1 + + + meter of water column + m H + + 2 + + O + + pressure + 9.80665 + + + meter of mercury column + m Hg + pressure + 133.3220 + + + inch of water column + in H + + 2 + + O + + pressure + 1 + + + inch of mercury column + in Hg + pressure + 1 + + + peripheral vascular resistance unit + P.R.U. + fluid resistance + 1 + + + Wood unit + Wood U. + fluid resistance + 1 + + + diopter + dpt + refraction of a lens + 1 + + + prism diopter + PD + refraction of a prism + + + + + + percent of slope + % + slope + + + + + + mesh + lineic number + 1 + + + Charrière + french + Ch + gauge of catheters + 1 + + + drop + drp + volume + 1 + + + Hounsfield unit + HF + x-ray attenuation + 1 + + + metabolic equivalent + MET + metabolic cost of physical activity + 3.5 + + + homeopathic potency of decimal series (retired) + X + homeopathic potency (retired) + + + + + + homeopathic potency of centesimal series (retired) + C + homeopathic potency (retired) + + + + + + homeopathic potency of millesimal series (retired) + M + homeopathic potency (retired) + + + + + + homeopathic potency of quintamillesimal series (retired) + Q + homeopathic potency (retired) + + + + + + homeopathic potency of decimal hahnemannian series + X + homeopathic potency (Hahnemann) + 1 + + + homeopathic potency of centesimal hahnemannian series + C + homeopathic potency (Hahnemann) + 1 + + + homeopathic potency of millesimal hahnemannian series + M + homeopathic potency (Hahnemann) + 1 + + + homeopathic potency of quintamillesimal hahnemannian series + Q + homeopathic potency (Hahnemann) + 1 + + + homeopathic potency of decimal korsakovian series + X + homeopathic potency (Korsakov) + 1 + + + homeopathic potency of centesimal korsakovian series + C + homeopathic potency (Korsakov) + 1 + + + homeopathic potency of millesimal korsakovian series + M + homeopathic potency (Korsakov) + 1 + + + homeopathic potency of quintamillesimal korsakovian series + Q + homeopathic potency (Korsakov) + 1 + + + equivalents + eq + amount of substance + 1 + + + osmole + osm + amount of substance (dissolved particles) + 1 + + + pH + pH + acidity + + + + + + gram percent + g% + mass concentration + 1 + + + Svedberg unit + S + sedimentation coefficient + 1 + + + high power field + HPF + view area in microscope + 1 + + + low power field + LPF + view area in microscope + 100 + + + katal + kat + catalytic activity + 1 + + + Unit + U + catalytic activity + 1 + + + international unit + IU + arbitrary + 1 + + + international unit + i.U. + arbitrary + 1 + + + arbitary unit + arb. U + arbitrary + 1 + + + United States Pharmacopeia unit + U.S.P. + arbitrary + 1 + + + GPL unit + biologic activity of anticardiolipin IgG + 1 + + + MPL unit + biologic activity of anticardiolipin IgM + 1 + + + APL unit + biologic activity of anticardiolipin IgA + 1 + + + Bethesda unit + biologic activity of factor VIII inhibitor + 1 + + + anti factor Xa unit + biologic activity of factor Xa inhibitor (heparin) + 1 + + + Todd unit + biologic activity antistreptolysin O + 1 + + + Dye unit + biologic activity of amylase + 1 + + + Somogyi unit + biologic activity of amylase + 1 + + + Bodansky unit + biologic activity of phosphatase + 1 + + + King-Armstrong unit + biologic activity of phosphatase + 1 + + + Kunkel unit + arbitrary biologic activity + 1 + + + Mac Lagan unit + arbitrary biologic activity + 1 + + + tuberculin unit + biologic activity of tuberculin + 1 + + + 50% cell culture infectious dose + CCID + 50 + + biologic activity (infectivity) of an infectious agent preparation + 1 + + + 50% tissue culture infectious dose + TCID + 50 + + biologic activity (infectivity) of an infectious agent preparation + 1 + + + 50% embryo infectious dose + EID + 50 + + biologic activity (infectivity) of an infectious agent preparation + 1 + + + plaque forming units + PFU + amount of an infectious agent + 1 + + + focus forming units + FFU + amount of an infectious agent + 1 + + + colony forming units + CFU + amount of a proliferating organism + 1 + + + index of reactivity + IR + amount of an allergen callibrated through in-vivo testing using the Stallergenes® + method. + + 1 + + + bioequivalent allergen unit + BAU + amount of an allergen callibrated through in-vivo testing based on the ID50EAL method + of (intradermal dilution for 50mm sum of erythema diameters + + 1 + + + allergen unit + AU + procedure defined amount of an allergen using some reference standard + 1 + + + allergen unit for Ambrosia artemisiifolia + Amb a 1 U + procedure defined amount of the major allergen of ragweed. + 1 + + + protein nitrogen unit + PNU + procedure defined amount of a protein substance + 1 + + + Limit of flocculation + Lf + procedure defined amount of an antigen substance + 1 + + + D-antigen unit + + procedure defined amount of a poliomyelitis d-antigen substance + 1 + + + fibrinogen equivalent unit + + amount of fibrinogen broken down into the measured d-dimers + 1 + + + ELISA unit + + arbitrary ELISA unit + 1 + + + Ehrlich unit + + Ehrlich unit + 1 + + + neper + Np + level + + + + + + bel + B + level + + + + + + bel sound pressure + B(SPL) + pressure level + + + + + + bel volt + B(V) + electric potential level + + + + + + bel millivolt + B(mV) + electric potential level + + + + + + bel microvolt + B(μV) + electric potential level + + + + + + bel 10 nanovolt + B(10 nV) + electric potential level + + + + + + bel watt + B(W) + power level + + + + + + bel kilowatt + B(kW) + power level + + + + + + stere + st + volume + 1 + + + Ångström + Å + length + 0.1 + + + barn + b + action area + 100 + + + technical atmosphere + at + pressure + 1 + + + mho + mho + electric conductance + 1 + + + pound per sqare inch + psi + pressure + 1 + + + circle + circ + plane angle + 2 + + + spere + sph + solid angle + 4 + + + metric carat + ct + m + + mass + 0.2 + + + carat of gold alloys + ct + + Au + + + mass fraction + 1 + + + Smoot + + length + 67 + + + meter per square seconds per square root of hertz + + amplitude spectral density + + + + + + bit + bit + s + + amount of information + + + + + + bit + bit + amount of information + 1 + + + byte + B + amount of information + 8 + + + baud + Bd + signal transmission rate + 1 + + + kibi + Ki + 1024 + + + mebi + Mi + 1048576 + + + gibi + Gi + 1073741824 + + + tebi + Ti + 1099511627776 + + \ No newline at end of file diff --git a/encoders/src/main/scala/au/csiro/pathling/encoders/QuantitySupport.scala b/encoders/src/main/scala/au/csiro/pathling/encoders/QuantitySupport.scala new file mode 100644 index 0000000000..e87cb3b947 --- /dev/null +++ b/encoders/src/main/scala/au/csiro/pathling/encoders/QuantitySupport.scala @@ -0,0 +1,74 @@ +/* + * 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 + +import au.csiro.pathling.encoders.terminology.ucum.Ucum +import au.csiro.pathling.sql.types.FlexiDecimal +import au.csiro.pathling.sql.types.FlexiDecimalSupport.createFlexiDecimalSerializer +import org.apache.spark.sql.Column +import org.apache.spark.sql.catalyst.expressions.objects.{Invoke, StaticInvoke} +import org.apache.spark.sql.catalyst.expressions.{CreateNamedStruct, Expression, If, IsNull, Literal} +import org.apache.spark.sql.functions.{lit, struct} +import org.apache.spark.sql.types.{DataTypes, Decimal, DecimalType, ObjectType, StructField} +import org.apache.spark.unsafe.types.UTF8String + +/** + * Helper class for serialization of Quantities. In order to improve the performance of + * comparisons we store with each quantity canonicalized value (its value in the base unit of the quantity) + * and the base (canonicalized) unit code. + */ +object QuantitySupport { + + val VALUE_CANONICALIZED_FIELD_NAME = "_value_canonicalized" + val CODE_CANONICALIZED_FIELD_NAME = "_code_canonicalized" + /** + * Creates additional serializers for serialization of quantities. + * + * @param expression the Quantity expression to serialize + * @return the serializers for canonicalized fields. + */ + def createExtraSerializers(expression: Expression): Seq[(String, Expression)] = { + val valueExp = Invoke(expression, "getValue", ObjectType(classOf[java.math.BigDecimal])) + val codeExp = Invoke(expression, "getCode", ObjectType(classOf[java.lang.String])) + + val canonicalizedValue = + createFlexiDecimalSerializer( + StaticInvoke(classOf[Ucum], ObjectType(classOf[java.math.BigDecimal]), + "getCanonicalValue", Seq(valueExp, codeExp))) + + val canonicalizedCode = + StaticInvoke( + classOf[UTF8String], + DataTypes.StringType, + "fromString", + StaticInvoke(classOf[Ucum], ObjectType(classOf[java.lang.String]), "getCanonicalCode", + Seq(valueExp, codeExp)) :: Nil) + Seq( + (VALUE_CANONICALIZED_FIELD_NAME, canonicalizedValue), + (CODE_CANONICALIZED_FIELD_NAME, canonicalizedCode) + ) + } + + /** + * Creates additional schema fields for quantities. + * + * @return the schema of canonicalized fields. + */ + def createExtraSchemaFields(): Seq[StructField] = { + Seq( + StructField(VALUE_CANONICALIZED_FIELD_NAME, FlexiDecimal.DATA_TYPE), + StructField(CODE_CANONICALIZED_FIELD_NAME, DataTypes.StringType) + ) + } +} diff --git a/encoders/src/main/scala/au/csiro/pathling/encoders/SchemaConverter.scala b/encoders/src/main/scala/au/csiro/pathling/encoders/SchemaConverter.scala index 08fdebd3fb..4ac654f317 100644 --- a/encoders/src/main/scala/au/csiro/pathling/encoders/SchemaConverter.scala +++ b/encoders/src/main/scala/au/csiro/pathling/encoders/SchemaConverter.scala @@ -14,12 +14,14 @@ package au.csiro.pathling.encoders import au.csiro.pathling.encoders.ExtensionSupport.{EXTENSIONS_FIELD_NAME, FID_FIELD_NAME} -import au.csiro.pathling.encoders.datatypes.DataTypeMappings +import au.csiro.pathling.encoders.QuantitySupport.{CODE_CANONICALIZED_FIELD_NAME, VALUE_CANONICALIZED_FIELD_NAME} +import au.csiro.pathling.encoders.datatypes.{DataTypeMappings, DecimalCustomCoder} import au.csiro.pathling.schema.SchemaVisitor import au.csiro.pathling.schema.SchemaVisitor.isCollection import ca.uhn.fhir.context._ import org.apache.spark.sql.types._ import org.hl7.fhir.instance.model.api.{IBase, IBaseResource} +import org.hl7.fhir.r4.model.Quantity /** * The schema processor for converting FHIR schemas to SQL schemas. @@ -53,9 +55,19 @@ private[encoders] class SchemaConverterProcessor(override val fhirContext: FhirC } } + private def createQuantityFields(definition: BaseRuntimeElementCompositeDefinition[_]): Seq[StructField] = { + definition.getImplementingClass match { + case cls if classOf[Quantity].isAssignableFrom(cls) => QuantitySupport + .createExtraSchemaFields() + case _ => Nil + } + } + override def buildComposite(definition: BaseRuntimeElementCompositeDefinition[_], fields: Seq[StructField]): DataType = { - StructType(fields ++ createFidField() ++ createExtensionField(definition)) + StructType( + fields ++ createQuantityFields(definition) ++ createFidField() ++ createExtensionField( + definition)) } override def buildElement(elementName: String, elementValue: DataType, @@ -120,4 +132,4 @@ class SchemaConverter(val fhirContext: FhirContext, val dataTypeMappings: DataTy def resourceSchema[T <: IBaseResource](resourceClass: Class[T]): StructType = { resourceSchema(fhirContext.getResourceDefinition(resourceClass)) } -} \ No newline at end of file +} diff --git a/encoders/src/main/scala/au/csiro/pathling/encoders/SerializerBuilder.scala b/encoders/src/main/scala/au/csiro/pathling/encoders/SerializerBuilder.scala index 28d0d3e628..69def3d53a 100644 --- a/encoders/src/main/scala/au/csiro/pathling/encoders/SerializerBuilder.scala +++ b/encoders/src/main/scala/au/csiro/pathling/encoders/SerializerBuilder.scala @@ -14,18 +14,20 @@ package au.csiro.pathling.encoders import au.csiro.pathling.encoders.ExtensionSupport.{EXTENSIONS_FIELD_NAME, FID_FIELD_NAME} +import au.csiro.pathling.encoders.QuantitySupport.{CODE_CANONICALIZED_FIELD_NAME, VALUE_CANONICALIZED_FIELD_NAME} import au.csiro.pathling.encoders.SerializerBuilderProcessor.{dataTypeToUtf8Expr, getChildExpression, objectTypeFor} -import au.csiro.pathling.encoders.datatypes.DataTypeMappings +import au.csiro.pathling.encoders.datatypes.{DataTypeMappings, DecimalCustomCoder} +import au.csiro.pathling.encoders.terminology.ucum.Ucum import au.csiro.pathling.schema.SchemaVisitor.isCollection import au.csiro.pathling.schema._ import ca.uhn.fhir.context.BaseRuntimeElementDefinition.ChildTypeEnum import ca.uhn.fhir.context._ import org.apache.spark.sql.catalyst.expressions.objects.{ExternalMapToCatalyst, Invoke, MapObjects, StaticInvoke} import org.apache.spark.sql.catalyst.expressions.{BoundReference, CreateNamedStruct, Expression, If, IsNull, Literal} -import org.apache.spark.sql.types.{DataType, DataTypes, IntegerType, ObjectType} +import org.apache.spark.sql.types._ import org.apache.spark.unsafe.types.UTF8String import org.hl7.fhir.instance.model.api.{IBaseDatatype, IBaseHasExtensions, IBaseResource} -import org.hl7.fhir.r4.model.{Base, Extension} +import org.hl7.fhir.r4.model.{Base, Extension, Quantity} import org.hl7.fhir.utilities.xhtml.XhtmlNode import scala.collection.convert.ImplicitConversions.`collection AsScalaIterable` @@ -106,20 +108,28 @@ private[encoders] class SerializerBuilderProcessor(expression: Expression, expression :: Nil)) :: maybeExtensionValueField } + private def createSyntheticSerializers(value: CompositeCtx[Expression, (String, Expression)]): Seq[(String, Expression)] = { + value.compositeDefinition.getImplementingClass match { + case cls if classOf[Quantity].isAssignableFrom(cls) => QuantitySupport + .createExtraSerializers(expression) + case _ => Nil + } + } + override def proceedCompositeChildren(value: CompositeCtx[Expression, (String, Expression)]): Seq[(String, Expression)] = { dataTypeMappings.overrideCompositeExpression(expression, value.compositeDefinition) - .getOrElse(super.proceedCompositeChildren(value)) + .getOrElse(super.proceedCompositeChildren(value) ++ createSyntheticSerializers(value)) + } override def buildComposite(definition: BaseRuntimeElementCompositeDefinition[_], fields: Seq[(String, Expression)]): Expression = { - val allFields = if (supportsExtensions) { + val allFields: Seq[(String, Expression)] = if (supportsExtensions) { fields ++ createExtensionsFields(definition) } else { fields } - val struct = CreateNamedStruct( allFields.flatMap({ case (name, serializer) => Seq(Literal(name), serializer) })) If(IsNull(expression), Literal.create(null, struct.dataType), struct) @@ -334,4 +344,4 @@ object SerializerBuilder { def apply(context: EncoderContext): SerializerBuilder = { new SerializerBuilder(context.fhirContext, context.dataTypeMappings, context.config) } -} \ No newline at end of file +} diff --git a/encoders/src/main/scala/au/csiro/pathling/encoders/datatypes/DecimalCustomCoder.scala b/encoders/src/main/scala/au/csiro/pathling/encoders/datatypes/DecimalCustomCoder.scala index 3dce19bfe0..d0e748dc27 100644 --- a/encoders/src/main/scala/au/csiro/pathling/encoders/datatypes/DecimalCustomCoder.scala +++ b/encoders/src/main/scala/au/csiro/pathling/encoders/datatypes/DecimalCustomCoder.scala @@ -115,12 +115,12 @@ object DecimalCustomCoder { * For location coordinates 6 decimal digits allow for location precision of 10cm, * so should be sufficient for any medical purpose. * - * So the final type is DECIMAL(26,6) which allows both for 6 decimal places and - * at least 18 digits (regardless if there any decimal digits or not) + * So the final type is DECIMAL(32,6) which allows both for 6 decimal places and 26 digits + * (regardless if there any decimal digits or not) */ val scale: Int = 6 - val precision: Int = 26 + val precision: Int = 32 val decimalType: types.DecimalType = DataTypes.createDecimalType(precision, scale) diff --git a/encoders/src/main/scala/au/csiro/pathling/sql/types/FlexiDecimalSupport.scala b/encoders/src/main/scala/au/csiro/pathling/sql/types/FlexiDecimalSupport.scala new file mode 100644 index 0000000000..2fb40ecd16 --- /dev/null +++ b/encoders/src/main/scala/au/csiro/pathling/sql/types/FlexiDecimalSupport.scala @@ -0,0 +1,56 @@ +package au.csiro.pathling.sql.types + +import org.apache.spark.sql.Column +import org.apache.spark.sql.catalyst.expressions.objects.{Invoke, StaticInvoke} +import org.apache.spark.sql.catalyst.expressions.{CreateNamedStruct, Expression, If, IsNull, Literal} +import org.apache.spark.sql.functions.{lit, struct} +import org.apache.spark.sql.types.{DataTypes, Decimal, ObjectType} + +/** + * Helper class for serialization of FlexiDecimals. + * + * @author Piotr Szul + */ +object FlexiDecimalSupport { + + def toLiteral(value: java.math.BigDecimal): Column = { + val normalizedValue = FlexiDecimal.normalize(value) + if (normalizedValue != null) { + struct( + lit(Decimal.apply(normalizedValue.unscaledValue())).cast(FlexiDecimal.DECIMAL_TYPE) + .as("value"), + lit(normalizedValue.scale()).as("scale") + ) + } else { + lit(null) + } + } + + def createFlexiDecimalSerializer(expression: Expression): Expression = { + // the expression is of type BigDecimal + // we want to encode it as a struct of two fields + // value -> the BigInteger representing digits + // scale -> the actual position of the decimal point + + // TODO: Performance: consider if the normalized value could be cached in + // a variable + val normalizedExpression: Expression = StaticInvoke(classOf[FlexiDecimal], + ObjectType(classOf[java.math.BigDecimal]), + "normalize", + expression :: Nil) + + val valueExpression: Expression = StaticInvoke(classOf[Decimal], + FlexiDecimal.DECIMAL_TYPE, + "apply", + Invoke(normalizedExpression, "unscaledValue", + ObjectType(classOf[java.math.BigInteger])) :: Nil) + + val scaleExpression: Expression = Invoke(normalizedExpression, "scale", DataTypes.IntegerType) + + val struct = CreateNamedStruct(Seq( + Literal("value"), valueExpression, + Literal("scale"), scaleExpression + )) + If(IsNull(expression), Literal.create(null, struct.dataType), struct) + } +} diff --git a/encoders/src/test/java/au/csiro/pathling/encoders/FhirEncodersTest.java b/encoders/src/test/java/au/csiro/pathling/encoders/FhirEncodersTest.java index c308986972..0813c4a736 100644 --- a/encoders/src/test/java/au/csiro/pathling/encoders/FhirEncodersTest.java +++ b/encoders/src/test/java/au/csiro/pathling/encoders/FhirEncodersTest.java @@ -48,6 +48,7 @@ import org.hl7.fhir.r4.model.Observation; import org.hl7.fhir.r4.model.Patient; import org.hl7.fhir.r4.model.Quantity; +import org.hl7.fhir.r4.model.Quantity.QuantityComparator; import org.hl7.fhir.r4.model.Questionnaire; import org.hl7.fhir.r4.model.QuestionnaireResponse; import org.junit.jupiter.api.AfterAll; @@ -535,4 +536,13 @@ public void testNestedQuestionnaire() { .getItem(0).getField("linkId")) .collectAsList()); } + + @Test + public void testQuantityComparator() { + final QuantityComparator originalComparator = observation.getValueQuantity().getComparator(); + final String queriedComparator = observationsDataset.select("valueQuantity.comparator").head() + .getString(0); + + assertEquals(originalComparator.toCode(), queriedComparator); + } } diff --git a/encoders/src/test/java/au/csiro/pathling/encoders/LightweightFhirEncodersTest.java b/encoders/src/test/java/au/csiro/pathling/encoders/LightweightFhirEncodersTest.java index 9e9685fbb3..ea465026a8 100644 --- a/encoders/src/test/java/au/csiro/pathling/encoders/LightweightFhirEncodersTest.java +++ b/encoders/src/test/java/au/csiro/pathling/encoders/LightweightFhirEncodersTest.java @@ -20,10 +20,12 @@ import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.assertTrue; +import au.csiro.pathling.sql.types.FlexiDecimal; import ca.uhn.fhir.context.FhirContext; import ca.uhn.fhir.parser.IParser; import java.math.BigDecimal; import java.math.RoundingMode; +import java.util.List; import java.util.Map; import java.util.function.Consumer; import org.apache.spark.sql.Row; @@ -32,9 +34,11 @@ import org.apache.spark.sql.catalyst.encoders.RowEncoder; import org.hl7.fhir.r4.model.BaseResource; import org.hl7.fhir.r4.model.Condition; +import org.hl7.fhir.r4.model.Device; import org.hl7.fhir.r4.model.IdType; import org.hl7.fhir.r4.model.MolecularSequence; import org.hl7.fhir.r4.model.MolecularSequence.MolecularSequenceQualityRocComponent; +import org.hl7.fhir.r4.model.Observation; import org.hl7.fhir.r4.model.PlanDefinition; import org.hl7.fhir.r4.model.PlanDefinition.PlanDefinitionActionComponent; import org.json4s.jackson.JsonMethods; @@ -95,6 +99,17 @@ public void assertSingletNestedExtension(final String expectedUrl, nestedConsumer.accept((Row) nestedExtensions.apply(0)); } + private static void assertQuantity(final Row quantityRow, final String canonicalizedValue, + final String canonicalizedCode) { + final BigDecimal actualCanonicalizedValue = FlexiDecimal.fromValue(quantityRow.getStruct( + quantityRow.fieldIndex(QuantitySupport.VALUE_CANONICALIZED_FIELD_NAME()))); + final String actualCanonicalizedCode = quantityRow.getString( + quantityRow.fieldIndex(QuantitySupport.CODE_CANONICALIZED_FIELD_NAME())); + + assertEquals(new BigDecimal(canonicalizedValue), actualCanonicalizedValue); + assertEquals(canonicalizedCode, actualCanonicalizedCode); + } + @Test public void testDecimalCollection() { final ExpressionEncoder encoder = fhirEncoders @@ -205,4 +220,46 @@ public void testEncodesExtensions() { assertNotNull(stageTypeExtensions); assertStringExtension("uuid:ext12", "ext12", (Row) stageTypeExtensions.apply(0)); } + + @Test + public void testQuantityCanonicalization() { + final ExpressionEncoder encoder = fhirEncoders.of(Observation.class); + final Observation observation = TestData.newUcumObservation(); + + final ExpressionEncoder resolvedEncoder = EncoderUtils.defaultResolveAndBind( + encoder); + final InternalRow serializedRow = resolvedEncoder.createSerializer().apply(observation); + + final ExpressionEncoder rowEncoder = EncoderUtils.defaultResolveAndBind( + RowEncoder.apply(encoder.schema())); + final Row observationRow = rowEncoder.createDeserializer().apply(serializedRow); + + final Row quantityRow = observationRow.getStruct(observationRow.fieldIndex("valueQuantity")); + assertQuantity(quantityRow, "76000", "g"); + } + + @Test + public void testQuantityArrayCanonicalization() { + final ExpressionEncoder encoder = fhirEncoders.of(Device.class); + final Device device = TestData.newDevice(); + + final ExpressionEncoder resolvedEncoder = EncoderUtils.defaultResolveAndBind( + encoder); + final InternalRow serializedRow = resolvedEncoder.createSerializer().apply(device); + + final ExpressionEncoder rowEncoder = EncoderUtils.defaultResolveAndBind( + RowEncoder.apply(encoder.schema())); + final Row deviceRow = rowEncoder.createDeserializer().apply(serializedRow); + + final List properties = deviceRow.getList(deviceRow.fieldIndex("property")); + final Row propertyRow = properties.get(0); + final List quantityArray = propertyRow.getList(propertyRow.fieldIndex("valueQuantity")); + + final Row quantity1 = quantityArray.get(0); + assertQuantity(quantity1, "0.0010", "m"); + + final Row quantity2 = quantityArray.get(1); + assertQuantity(quantity2, "0.0020", "m"); + } + } diff --git a/encoders/src/test/java/au/csiro/pathling/encoders/SchemaConverterTest.java b/encoders/src/test/java/au/csiro/pathling/encoders/SchemaConverterTest.java index 95e8ca13cf..35ee6e9270 100644 --- a/encoders/src/test/java/au/csiro/pathling/encoders/SchemaConverterTest.java +++ b/encoders/src/test/java/au/csiro/pathling/encoders/SchemaConverterTest.java @@ -20,6 +20,7 @@ import au.csiro.pathling.encoders.datatypes.DataTypeMappings; import au.csiro.pathling.encoders.datatypes.R4DataTypeMappings; +import au.csiro.pathling.sql.types.FlexiDecimal; import ca.uhn.fhir.context.FhirContext; import java.util.Arrays; import java.util.List; @@ -39,6 +40,7 @@ import org.apache.spark.sql.types.StructType; import org.apache.spark.sql.types.TimestampType; import org.hl7.fhir.r4.model.Condition; +import org.hl7.fhir.r4.model.Device; import org.hl7.fhir.r4.model.MedicationRequest; import org.hl7.fhir.r4.model.Observation; import org.hl7.fhir.r4.model.Questionnaire; @@ -82,6 +84,8 @@ public class SchemaConverterTest { private StructType questionnaireSchema; private StructType questionnaireResponseSchema; + private StructType deviceSchema; + /** * Traverses a DataType recursively passing all encountered StructTypes to the provided consumer. @@ -93,7 +97,9 @@ private void traverseSchema(final DataType type, final Consumer cons if (type instanceof StructType) { final StructType structType = (StructType) type; consumer.accept(structType); - Arrays.stream(structType.fields()).forEach(f -> traverseSchema(f.dataType(), consumer)); + Arrays.stream(structType.fields()) + .filter(f -> !f.name().startsWith("_")) // filter out synthetic fields + .forEach(f -> traverseSchema(f.dataType(), consumer)); } else if (type instanceof ArrayType) { traverseSchema(((ArrayType) type).elementType(), consumer); } else if (type instanceof MapType) { @@ -156,6 +162,7 @@ public void setUp() { medRequestSchema = converter_L0.resourceSchema(MedicationRequest.class); questionnaireSchema = converter_L0.resourceSchema(Questionnaire.class); questionnaireResponseSchema = converter_L0.resourceSchema(QuestionnaireResponse.class); + deviceSchema = converter_L0.resourceSchema(Device.class); } @Test @@ -387,4 +394,33 @@ public void testRestrictsOpenTypesCorrectly() { .filter(fn -> fn.startsWith("value")).collect(Collectors.toUnmodifiableSet()); assertEquals(Set.of("valueBoolean", "valueInteger", "valueCoding"), actualOpenTypeFieldNames); } + + @Test + public void testQuantity() { + final DataType quantityType = getField(observationSchema, true, "valueQuantity"); + assertQuantityType(quantityType); + } + + @Test + public void testSimpleQuantity() { + final DataType quantityType = getField(medRequestSchema, true, "dispenseRequest", "quantity"); + assertQuantityType(quantityType); + } + + @Test + public void testQuantityArray() { + final DataType quantityType = getField(deviceSchema, true, "property", "valueQuantity"); + assertQuantityType(quantityType); + } + + private void assertQuantityType(final DataType quantityType) { + assertTrue(getField(quantityType, true, "value") instanceof DecimalType); + assertTrue(getField(quantityType, true, "value_scale") instanceof IntegerType); + assertTrue(getField(quantityType, true, "comparator") instanceof StringType); + assertTrue(getField(quantityType, true, "unit") instanceof StringType); + assertTrue(getField(quantityType, true, "system") instanceof StringType); + assertTrue(getField(quantityType, true, "code") instanceof StringType); + assertEquals(FlexiDecimal.DATA_TYPE, getField(quantityType, true, "_value_canonicalized")); + assertTrue(getField(quantityType, true, "_code_canonicalized") instanceof StringType); + } } diff --git a/encoders/src/test/java/au/csiro/pathling/encoders/TestData.java b/encoders/src/test/java/au/csiro/pathling/encoders/TestData.java index 7c6aeb7b31..2f03e45706 100644 --- a/encoders/src/test/java/au/csiro/pathling/encoders/TestData.java +++ b/encoders/src/test/java/au/csiro/pathling/encoders/TestData.java @@ -27,6 +27,8 @@ import org.hl7.fhir.r4.model.Condition.ConditionStageComponent; import org.hl7.fhir.r4.model.DateTimeType; import org.hl7.fhir.r4.model.DecimalType; +import org.hl7.fhir.r4.model.Device; +import org.hl7.fhir.r4.model.Device.DevicePropertyComponent; import org.hl7.fhir.r4.model.Encounter; import org.hl7.fhir.r4.model.Extension; import org.hl7.fhir.r4.model.IdType; @@ -42,6 +44,7 @@ import org.hl7.fhir.r4.model.Provenance; import org.hl7.fhir.r4.model.Provenance.ProvenanceEntityRole; import org.hl7.fhir.r4.model.Quantity; +import org.hl7.fhir.r4.model.Quantity.QuantityComparator; import org.hl7.fhir.r4.model.Questionnaire; import org.hl7.fhir.r4.model.Questionnaire.QuestionnaireItemComponent; import org.hl7.fhir.r4.model.QuestionnaireResponse; @@ -151,6 +154,7 @@ public static Observation newObservation() { final Quantity quantity = new Quantity(); quantity.setValue(TEST_SMALL_DECIMAL); quantity.setUnit("mm[Hg]"); + quantity.setComparator(QuantityComparator.LESS_THAN); observation.setValue(quantity); observation.setIssued(TEST_DATE); @@ -160,6 +164,38 @@ public static Observation newObservation() { return observation; } + public static Observation newUcumObservation() { + final Observation observation = new Observation(); + observation.setId("weight"); + + final Quantity quantity = new Quantity(); + quantity.setValue(76); + quantity.setUnit("kg"); + quantity.setSystem("http://unitsofmeasure.org"); + quantity.setCode("kg"); + + observation.setValue(quantity); + + return observation; + } + + public static Device newDevice() { + final Device device = new Device(); + device.setId("some-device"); + + final DevicePropertyComponent property = new DevicePropertyComponent(); + property.setType( + new CodeableConcept(new Coding("urn:example:abc", "12345", "Some property"))); + final Quantity quantity1 = new Quantity(null, 1.0, "http://unitsofmeasure.org", "mm", "mm"); + final Quantity quantity2 = new Quantity(null, 2.0, "http://unitsofmeasure.org", "mm", "mm"); + final List quantities = List.of(quantity1, quantity2); + property.setValueQuantity(quantities); + final List properties = List.of(property); + device.setProperty(properties); + + return device; + } + /** * Returns a FHIR Patient for testing purposes. */ diff --git a/encoders/src/test/java/au/csiro/pathling/sql/types/FlexiDecimalTest.java b/encoders/src/test/java/au/csiro/pathling/sql/types/FlexiDecimalTest.java new file mode 100644 index 0000000000..25179eb7f1 --- /dev/null +++ b/encoders/src/test/java/au/csiro/pathling/sql/types/FlexiDecimalTest.java @@ -0,0 +1,32 @@ +package au.csiro.pathling.sql.types; + +import org.junit.jupiter.api.Test; +import java.math.BigDecimal; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; + +public class FlexiDecimalTest { + + @Test + void testNormalize() { + // Normalize big decimal with negative scale + assertEquals(new BigDecimal("123000"), FlexiDecimal.normalize(new BigDecimal("1.23E+5"))); + assertEquals(new BigDecimal("99900000000000000000000000000000000000"), + FlexiDecimal.normalize(new BigDecimal("9.99E+37"))); + // To many significant digits --> null + assertNull(FlexiDecimal.normalize(new BigDecimal("1.0E+38"))); + + // normalize decimals to reduced precision + assertEquals(new BigDecimal("0.010000000000000000000000000000000000000"), + FlexiDecimal.normalize(new BigDecimal("0.010000000000000000000000000000000000000000000"))); + + assertEquals(FlexiDecimal.MAX_PRECISION, + FlexiDecimal.normalize(new BigDecimal("0.010000000000000000000000000000000000000000000")) + .precision()); + + assertEquals(new BigDecimal("0.015555555555555555555555555555555555556"), + FlexiDecimal.normalize(new BigDecimal( + "0.01555555555555555555555555555555555555555555555555555555555555555555555555"))); + } +} diff --git a/fhir-server/azure-pipelines.yml b/fhir-server/azure-pipelines.yml deleted file mode 100644 index 9a04ce812e..0000000000 --- a/fhir-server/azure-pipelines.yml +++ /dev/null @@ -1,68 +0,0 @@ -name: pathling-$(Date:yyyyMMdd)$(Rev:.r) - -trigger: none - -pr: - branches: - exclude: - - dependabot/* - -pool: - vmImage: 'ubuntu-latest' - -variables: - mavenCache: $(Pipeline.Workspace)/.m2/repository - mavenOptions: '-Dmaven.repo.local=$(mavenCache)' - branchTag: $[replace(variables['System.PullRequest.SourceBranch'], '/', '-')] - -stages: - - stage: build - displayName: Build - jobs: - - job: build - displayName: Build - steps: - - task: Cache@2 - displayName: Cache Maven local repo - inputs: - key: 'maven | "$(Agent.OS)" | **/pom.xml' - restoreKeys: | - maven | "$(Agent.OS)" - maven - path: $(mavenCache) - - task: Maven@3 - displayName: Build and verify - inputs: - options: '-pl fhir-server -am -Pdocker -Dpathling.systemTest.auth.clientSecret=$(testClientSecret)' - mavenOptions: '$(mavenOptions)' - javaHomeOption: 'JDKVersion' - jdkVersionOption: '1.11' - jdkArchitectureOption: 'x64' - goals: 'verify' - timeoutInMinutes: 60 - - task: Docker@2 - condition: succeeded() - displayName: Tag image - inputs: - containerRegistry: $(containerRegistry) - repository: $(dockerRepo) - command: tag - arguments: aehrc/pathling:latest $(dockerRegistry)/$(dockerRepo):$(Build.BuildNumber) - - task: Docker@2 - condition: succeeded() - displayName: Tag image - inputs: - containerRegistry: $(containerRegistry) - repository: $(dockerRepo) - command: tag - arguments: aehrc/pathling:latest $(dockerRegistry)/$(dockerRepo):$(branchTag) - - task: Docker@2 - condition: succeeded() - displayName: Push image - inputs: - containerRegistry: $(containerRegistry) - repository: $(dockerRepo) - command: push - tags: | - $(Build.BuildNumber) - $(branchTag) diff --git a/fhir-server/pom.xml b/fhir-server/pom.xml index fd6d6d2ab1..72e3710956 100644 --- a/fhir-server/pom.xml +++ b/fhir-server/pom.xml @@ -13,7 +13,7 @@ au.csiro.pathling pathling - 5.4.0 + 6.0.0-SNAPSHOT fhir-server jar @@ -312,6 +312,7 @@ true file://${project.basedir}/src/test/resources/test-data parquet + UTC @@ -329,6 +330,7 @@ file://${project.basedir}/src/test/resources/test-data parquet + UTC @@ -376,9 +378,7 @@ ${project.version} - - -Xmx2g -XX:MaxMetaspaceSize=400m -XX:ReservedCodeCacheSize=240m -Xss1m - + -Xmx2g -XX:MaxMetaspaceSize=400m -XX:ReservedCodeCacheSize=240m -Xss1m -Duser.timezone=UTC Copyright © 2018-2022, Commonwealth Scientific and Industrial Research Organisation (CSIRO) ABN 41 687 119 230. Licensed under the CSIRO Open Source Software Licence Agreement. @@ -582,6 +582,44 @@ + + dockerPreRelease + + + + com.google.cloud.tools + jib-maven-plugin + + + deploy + deploy + + build + + + + ${pathling.dockerBaseImage} + + + amd64 + linux + + + arm64 + linux + + + + + ${pathling.fhirServerDockerRepo}:${pathling.fhirServerDockerTag}-develop + + + + + + + + testTranche1 diff --git a/fhir-server/src/main/antlr4/au/csiro/pathling/fhirpath/parser/generated/FhirPath.g4 b/fhir-server/src/main/antlr4/au/csiro/pathling/fhirpath/parser/generated/FhirPath.g4 index 34001bc72d..175c0d8874 100644 --- a/fhir-server/src/main/antlr4/au/csiro/pathling/fhirpath/parser/generated/FhirPath.g4 +++ b/fhir-server/src/main/antlr4/au/csiro/pathling/fhirpath/parser/generated/FhirPath.g4 @@ -80,11 +80,11 @@ unit ; dateTimePrecision - : 'year' | 'month' | 'week' | 'day' | 'hour' | 'minute' | 'second' | 'millisecond' + : 'year' | 'month' | 'week' | 'day' | 'hour' | 'minute' | 'second' ; pluralDateTimePrecision - : 'years' | 'months' | 'weeks' | 'days' | 'hours' | 'minutes' | 'seconds' | 'milliseconds' + : 'years' | 'months' | 'weeks' | 'days' | 'hours' | 'minutes' | 'seconds' ; typeSpecifier diff --git a/fhir-server/src/main/java/au/csiro/pathling/aggregate/AggregateExecutor.java b/fhir-server/src/main/java/au/csiro/pathling/aggregate/AggregateExecutor.java index 16ba5cc559..eadc102928 100644 --- a/fhir-server/src/main/java/au/csiro/pathling/aggregate/AggregateExecutor.java +++ b/fhir-server/src/main/java/au/csiro/pathling/aggregate/AggregateExecutor.java @@ -19,7 +19,7 @@ import au.csiro.pathling.fhirpath.parser.Parser; import au.csiro.pathling.fhirpath.parser.ParserContext; import au.csiro.pathling.io.Database; -import au.csiro.pathling.sql.PathlingFunctions; +import au.csiro.pathling.sql.SqlExpressions; import ca.uhn.fhir.context.FhirContext; import java.util.ArrayList; import java.util.Collection; @@ -112,7 +112,7 @@ public ResultWithExpressions buildQuery(@Nonnull final AggregateRequest query) { // Remove synthetic fields from struct values (such as _fid) before grouping. final DatasetWithColumnMap datasetWithNormalizedGroupings = createColumns( groupingsAndFilters, groupings.stream().map(FhirPath::getValueColumn) - .map(PathlingFunctions::pruneSyntheticFields).toArray(Column[]::new)); + .map(SqlExpressions::pruneSyntheticFields).toArray(Column[]::new)); groupingsAndFilters = datasetWithNormalizedGroupings.getDataset(); diff --git a/fhir-server/src/main/java/au/csiro/pathling/config/StorageConfiguration.java b/fhir-server/src/main/java/au/csiro/pathling/config/StorageConfiguration.java index f9535f347f..cfbe3ec7e3 100644 --- a/fhir-server/src/main/java/au/csiro/pathling/config/StorageConfiguration.java +++ b/fhir-server/src/main/java/au/csiro/pathling/config/StorageConfiguration.java @@ -6,15 +6,10 @@ package au.csiro.pathling.config; -import java.util.Optional; -import javax.annotation.Nonnull; -import javax.annotation.Nullable; import javax.validation.constraints.NotBlank; -import javax.validation.constraints.NotNull; import javax.validation.constraints.Pattern; import javax.validation.constraints.Size; import lombok.Data; -import lombok.ToString; /** * Configuration relating to the storage of data. @@ -38,55 +33,4 @@ public class StorageConfiguration { @Size(min = 1, max = 50) private String databaseName; - @NotNull - private Aws aws; - - /** - * Configuration relating to storage of data using Amazon Web Services (AWS). - */ - @Data - public static class Aws { - - /** - * Public buckets can be accessed by default, set this to false to access protected buckets. - */ - @NotNull - private boolean anonymousAccess; - - /** - * Authentication details for connecting to a protected Amazon S3 bucket. - */ - @Nullable - private String accessKeyId; - - /** - * Authentication details for connecting to a protected Amazon S3 bucket. - */ - @Nullable - @ToString.Exclude - private String secretAccessKey; - - /** - * The ARN of an IAM role that should be assumed using STS. - */ - @Nullable - private String assumedRole; - - @Nonnull - public Optional getAccessKeyId() { - return Optional.ofNullable(accessKeyId); - } - - @Nonnull - public Optional getSecretAccessKey() { - return Optional.ofNullable(secretAccessKey); - } - - @Nonnull - public Optional getAssumedRole() { - return Optional.ofNullable(assumedRole); - } - - } - } diff --git a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/CalendarDurationUtils.java b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/CalendarDurationUtils.java new file mode 100644 index 0000000000..d221d34702 --- /dev/null +++ b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/CalendarDurationUtils.java @@ -0,0 +1,80 @@ +package au.csiro.pathling.fhirpath; + +import static au.csiro.pathling.utilities.Preconditions.checkUserInput; + +import com.google.common.collect.ImmutableMap; +import java.math.BigDecimal; +import java.util.Calendar; +import java.util.Map; +import java.util.regex.Matcher; +import java.util.regex.Pattern; +import javax.annotation.Nonnull; +import org.hl7.fhir.r4.model.Quantity; + +/** + * Utility methods for working with calendar durations. + * + * @author Piotr Szul + */ +public final class CalendarDurationUtils { + + private CalendarDurationUtils() { + // Toolkit class + } + + public static final String FHIRPATH_CALENDAR_DURATION_URI = "https://hl7.org/fhirpath/N1/calendar-duration"; + private static final Pattern CALENDAR_DURATION_PATTERN = Pattern.compile("([0-9.]+) (\\w+)"); + + private static final Map CALENDAR_DURATION_TO_UCUM = new ImmutableMap.Builder().put( + "year", Calendar.YEAR).put("years", Calendar.YEAR).put("month", Calendar.MONTH) + .put("months", Calendar.MONTH).put("day", Calendar.DATE).put("days", Calendar.DATE) + .put("hour", Calendar.HOUR).put("hours", Calendar.HOUR).put("minute", Calendar.MINUTE) + .put("minutes", Calendar.MINUTE).put("second", Calendar.SECOND) + .put("seconds", Calendar.SECOND).put("millisecond", Calendar.MILLISECOND) + .put("milliseconds", Calendar.MILLISECOND).build(); + + + public static int ucumToCalendarTemporalUnit(@Nonnull final String ucumTemporalUnit) { + final Integer temporalUnit = CALENDAR_DURATION_TO_UCUM.get( + ucumTemporalUnit); + checkUserInput(temporalUnit != null, + "Unsupported calendar duration unit: " + ucumTemporalUnit); + return temporalUnit; + } + + public static boolean isCalendarDuration(@Nonnull final Quantity maybeCalendarDuration) { + return maybeCalendarDuration.getSystem() + .equals(FHIRPATH_CALENDAR_DURATION_URI); + } + + @Nonnull + public static Quantity ensureCalendarDuration(@Nonnull final Quantity maybeCalendarDuration) { + if (!isCalendarDuration(maybeCalendarDuration)) { + throw new IllegalArgumentException("Calendar duration must have a system of " + + FHIRPATH_CALENDAR_DURATION_URI); + } + return maybeCalendarDuration; + } + + public static int getTemporalUnit(@Nonnull final Quantity calendarDuration) { + return ucumToCalendarTemporalUnit(ensureCalendarDuration(calendarDuration).getCode()); + } + + @Nonnull + public static Quantity parseCalendarDuration(@Nonnull final String calendarDurationString) { + final Matcher matcher = CALENDAR_DURATION_PATTERN.matcher(calendarDurationString); + if (!matcher.matches()) { + throw new IllegalArgumentException( + "Calendar duration literal has invalid format: " + calendarDurationString); + } + final String value = matcher.group(1); + final String keyword = matcher.group(2); + + final Quantity calendarDuration = new Quantity(); + calendarDuration.setValue(new BigDecimal(value)); + calendarDuration.setSystem(FHIRPATH_CALENDAR_DURATION_URI); + calendarDuration.setCode(keyword); + return calendarDuration; + } + +} diff --git a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/Comparable.java b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/Comparable.java index 4c5653d282..de18e4117b 100644 --- a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/Comparable.java +++ b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/Comparable.java @@ -6,18 +6,83 @@ package au.csiro.pathling.fhirpath; -import java.util.function.BiFunction; import java.util.function.Function; import javax.annotation.Nonnull; +import org.apache.commons.lang3.function.TriFunction; import org.apache.spark.sql.Column; +import org.apache.spark.sql.functions; /** * Describes a path that can be compared with other paths, e.g. for equality. * * @author John Grimes + * @author Piotr Szul */ public interface Comparable { + /** + * The interface that defines comparison operation on columns. The actual implementation and the + * implemented operation depend on the type of value in the column. + */ + interface SqlComparator { + + Column equalsTo(Column left, Column right); + + default Column notEqual(final Column left, final Column right) { + return functions.not(equalsTo(left, right)); + } + + Column lessThan(Column left, Column right); + + default Column lessThanOrEqual(final Column left, final Column right) { + return lessThan(left, right).or(equalsTo(left, right)); + } + + Column greaterThan(Column left, Column right); + + default Column greaterThanOrEqual(final Column left, final Column right) { + return greaterThan(left, right).or(equalsTo(left, right)); + } + } + + /** + * The implementation of comparator that use the standard Spark SQL operators. + */ + class StandardSqlComparator implements SqlComparator { + + @Override + public Column equalsTo(@Nonnull final Column left, @Nonnull final Column right) { + return left.equalTo(right); + } + + @Override + public Column notEqual(@Nonnull final Column left, @Nonnull final Column right) { + return left.notEqual(right); + } + + @Override + public Column lessThan(@Nonnull final Column left, @Nonnull final Column right) { + return left.lt(right); + } + + @Override + public Column lessThanOrEqual(@Nonnull final Column left, @Nonnull final Column right) { + return left.leq(right); + } + + @Override + public Column greaterThan(@Nonnull final Column left, @Nonnull final Column right) { + return left.gt(right); + } + + @Override + public Column greaterThanOrEqual(@Nonnull final Column left, @Nonnull final Column right) { + return left.geq(right); + } + } + + SqlComparator STD_SQL_COMPARATOR = new StandardSqlComparator(); + /** * Get a function that can take two Comparable paths and return a {@link Column} that contains a * comparison condition. The type of condition is controlled by supplying a @@ -45,16 +110,35 @@ public interface Comparable { boolean isComparableTo(@Nonnull Class type); /** - * Builds a comparison function for directly comparable paths. + * Builds a comparison function for directly comparable paths using the custom comparator. * * @param source The path to build the comparison function for - * @param sparkFunction The Spark column function to use + * @param operation The {@link ComparisonOperation} type to retrieve a comparison for + * @param sqlComparator The {@link SqlComparator} to use * @return A new {@link Function} */ @Nonnull static Function buildComparison(@Nonnull final Comparable source, - @Nonnull final BiFunction sparkFunction) { - return target -> sparkFunction.apply(source.getValueColumn(), target.getValueColumn()); + @Nonnull final ComparisonOperation operation, @Nonnull final SqlComparator sqlComparator) { + + final TriFunction compFunction = operation.compFunction; + + return target -> compFunction + .apply(sqlComparator, source.getValueColumn(), target.getValueColumn()); + } + + /** + * Builds a comparison function for directly comparable paths using the standard Spark SQL + * comparison operators. + * + * @param source The path to build the comparison function for + * @param operation The {@link ComparisonOperation} type to retrieve a comparison for + * @return A new {@link Function} + */ + static Function buildComparison(@Nonnull final Comparable source, + @Nonnull final ComparisonOperation operation) { + + return buildComparison(source, operation, STD_SQL_COMPARATOR); } /** @@ -64,52 +148,43 @@ enum ComparisonOperation { /** * The equals operation. */ - EQUALS("=", Column::equalTo), + EQUALS("=", SqlComparator::equalsTo), /** * The not equals operation. */ - NOT_EQUALS("!=", Column::notEqual), + NOT_EQUALS("!=", SqlComparator::notEqual), /** * The less than or equal to operation. */ - LESS_THAN_OR_EQUAL_TO("<=", Column::leq), + LESS_THAN_OR_EQUAL_TO("<=", SqlComparator::lessThanOrEqual), /** * The less than operation. */ - LESS_THAN("<", Column::lt), + LESS_THAN("<", SqlComparator::lessThan), /** * The greater than or equal to operation. */ - GREATER_THAN_OR_EQUAL_TO(">=", Column::geq), + GREATER_THAN_OR_EQUAL_TO(">=", SqlComparator::greaterThanOrEqual), /** * The greater than operation. */ - GREATER_THAN(">", Column::gt); + GREATER_THAN(">", SqlComparator::greaterThan); @Nonnull private final String fhirPath; - /** - * A Spark function that can be used to execute this type of comparison for simple types. - * Complex types such as Coding and Quantity will implement their own comparison functions. - */ @Nonnull - private final BiFunction sparkFunction; + private final TriFunction compFunction; ComparisonOperation(@Nonnull final String fhirPath, - @Nonnull final BiFunction sparkFunction) { + @Nonnull final TriFunction compFunction) { this.fhirPath = fhirPath; - this.sparkFunction = sparkFunction; - } - - @Nonnull - public BiFunction getSparkFunction() { - return sparkFunction; + this.compFunction = compFunction; } @Override @@ -117,6 +192,5 @@ public BiFunction getSparkFunction() { public String toString() { return fhirPath; } - } } diff --git a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/FhirPath.java b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/FhirPath.java index ce5840304f..251663f711 100644 --- a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/FhirPath.java +++ b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/FhirPath.java @@ -95,4 +95,14 @@ NonLiteralPath combineWith(@Nonnull FhirPath target, @Nonnull Dataset datas @Nonnull String expression, @Nonnull Column idColumn, @Nonnull Optional eidColumn, @Nonnull Column valueColumn, boolean singular, @Nonnull Optional thisColumn); + + /** + * Prints out to stdout all the ids and values of all the elements in this path. For debugging + * purposes only. + */ + default void dumpAll() { + getDataset().select(getIdColumn(), getValueColumn()).collectAsList() + .forEach(System.out::println); + } + } diff --git a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/Numeric.java b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/Numeric.java index a76eaea6a8..842b9ee86c 100644 --- a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/Numeric.java +++ b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/Numeric.java @@ -13,6 +13,7 @@ import org.apache.spark.sql.Column; import org.apache.spark.sql.Dataset; import org.apache.spark.sql.Row; +import org.hl7.fhir.r4.model.Enumerations.FHIRDefinedType; /** * Describes a path that represents a numeric value, and can be the subject of math operations. @@ -48,6 +49,34 @@ Function getMathOperation(@Nonnull MathOperation operat @Nonnull Column getValueColumn(); + /** + * @return a {@link Column} that provides a value that can me used in math operations + */ + @Nonnull + Column getNumericValueColumn(); + + /** + * Provides a {@link Column} that provides additional context that informs the way that math + * operations are carried out. This is used for Quantity math, so that the operation function has + * access to the canonicalized units. + * + * @return a {@link Column} that provides additional context for math operations + */ + @Nonnull + Column getNumericContextColumn(); + + /** + * The FHIR data type of the element being represented by this expression. + *

+ * Note that there can be multiple valid FHIR types for a given FHIRPath type, e.g. {@code uri} + * and {@code code} both map to the {@code String} FHIRPath type. + * + * @return the FHIR data type of the expression + * @see Using FHIR types in expressions + */ + @Nonnull + FHIRDefinedType getFhirType(); + /** * Represents a type of math operator. */ diff --git a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/Temporal.java b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/Temporal.java new file mode 100644 index 0000000000..7461038d0e --- /dev/null +++ b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/Temporal.java @@ -0,0 +1,91 @@ +/* + * 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.fhirpath; + +import au.csiro.pathling.fhirpath.Numeric.MathOperation; +import au.csiro.pathling.fhirpath.element.ElementPath; +import au.csiro.pathling.fhirpath.literal.QuantityLiteralPath; +import java.util.Optional; +import java.util.function.Function; +import javax.annotation.Nonnull; +import org.apache.spark.sql.Column; +import org.apache.spark.sql.Dataset; +import org.apache.spark.sql.Row; +import org.apache.spark.sql.functions; +import org.hl7.fhir.r4.model.Enumerations.FHIRDefinedType; + +/** + * Describes a path that represents a temporal value such as DateTime or Date, and can be the + * subject of date arithmetic operations involving time durations. + * + * @author John Grimes + */ +public interface Temporal { + + /** + * Gets a function that can take the {@link QuantityLiteralPath} representing a time duration and + * return a {@link FhirPath} that contains the result of date arithmetic operation for this path + * and the provided duration. The type of operation is controlled by supplying a {@link + * MathOperation}. + * + * @param operation The {@link MathOperation} type to retrieve a result for + * @param dataset The {@link Dataset} to use within the result + * @param expression The FHIRPath expression to use within the result + * @return A {@link Function} that takes a {@link QuantityLiteralPath} as its parameter, and + * returns a {@link FhirPath}. + */ + @Nonnull + Function getDateArithmeticOperation( + @Nonnull MathOperation operation, @Nonnull Dataset dataset, + @Nonnull String expression); + + /** + * Gets a function that can take the {@link QuantityLiteralPath} representing a time duration and + * return a {@link FhirPath} that contains the result of applying the date arithmetic operation + * for to the source path and the provided duration. The type of operation is controlled by + * supplying a {@link MathOperation}. + * + * @param source the {@link FhirPath} to which the operation should be applied to. Should be a + * {@link Temporal} path. + * @param operation The {@link MathOperation} type to retrieve a result for + * @param dataset The {@link Dataset} to use within the result + * @param expression the FHIRPath expression to use within the result + * @param additionFunctionName the name of the UDF to use for additions. + * @param subtractionFunctionName the name of the UDF to use for subtractions. + * @return A {@link Function} that takes a {@link QuantityLiteralPath} as its parameter, and + * returns a {@link FhirPath}. + */ + @Nonnull + static Function buildDateArithmeticOperation( + @Nonnull final FhirPath source, final @Nonnull MathOperation operation, + final @Nonnull Dataset dataset, final @Nonnull String expression, + final String additionFunctionName, final String subtractionFunctionName) { + return target -> { + final String functionName; + final Optional eidColumn = NonLiteralPath.findEidColumn(source, target); + final Optional thisColumn = NonLiteralPath.findThisColumn(source, target); + + switch (operation) { + case ADDITION: + functionName = additionFunctionName; + break; + case SUBTRACTION: + functionName = subtractionFunctionName; + break; + default: + throw new AssertionError("Unsupported date arithmetic operation: " + operation); + } + + final Column valueColumn = functions.callUDF(functionName, source.getValueColumn(), + target.getValueColumn()); + return ElementPath.build(expression, dataset, source.getIdColumn(), eidColumn, valueColumn, + true, + Optional.empty(), thisColumn, FHIRDefinedType.DATETIME); + }; + } + +} diff --git a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/comparison/CodingSqlComparator.java b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/comparison/CodingSqlComparator.java new file mode 100644 index 0000000000..da461a4ab5 --- /dev/null +++ b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/comparison/CodingSqlComparator.java @@ -0,0 +1,70 @@ +/* + * 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.fhirpath.comparison; + +import static org.apache.spark.sql.functions.lit; + +import au.csiro.pathling.errors.InvalidUserInputError; +import au.csiro.pathling.fhirpath.Comparable; +import au.csiro.pathling.fhirpath.Comparable.ComparisonOperation; +import au.csiro.pathling.fhirpath.Comparable.SqlComparator; +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; +import javax.annotation.Nonnull; +import org.apache.spark.sql.Column; +import org.apache.spark.sql.functions; + +/** + * Implementation of comparator for Coding type. + * + * @author Piotr Szul + */ +public class CodingSqlComparator implements SqlComparator { + + private static final List EQUALITY_COLUMNS = Arrays + .asList("system", "code", "version", "display", "userSelected"); + + private static final CodingSqlComparator INSTANCE = new CodingSqlComparator(); + + @Override + public Column equalsTo(@Nonnull final Column left, @Nonnull final Column right) { + //noinspection OptionalGetWithoutIsPresent + return functions.when(left.isNull().or(right.isNull()), lit(null)) + .otherwise( + EQUALITY_COLUMNS.stream() + .map(f -> left.getField(f).eqNullSafe(right.getField(f))).reduce(Column::and).get() + ); + } + + @Override + public Column lessThan(final Column left, final Column right) { + throw new InvalidUserInputError( + "Coding type does not support comparison operator: " + "lessThan"); + + } + + @Override + public Column greaterThan(final Column left, final Column right) { + throw new InvalidUserInputError( + "Coding type does not support comparison operator: " + "greaterThan"); + } + + /** + * Builds a comparison function for Coding paths. + * + * @param source The path to build the comparison function for + * @param operation The {@link au.csiro.pathling.fhirpath.Comparable.ComparisonOperation} type to + * build + * @return A new {@link Function} + */ + @Nonnull + public static Function buildComparison(@Nonnull final Comparable source, + @Nonnull final ComparisonOperation operation) { + return Comparable.buildComparison(source, operation, INSTANCE); + } +} diff --git a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/comparison/DateTimeSqlComparator.java b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/comparison/DateTimeSqlComparator.java new file mode 100644 index 0000000000..f52d03607a --- /dev/null +++ b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/comparison/DateTimeSqlComparator.java @@ -0,0 +1,63 @@ +package au.csiro.pathling.fhirpath.comparison; + +import static org.apache.spark.sql.functions.callUDF; + +import au.csiro.pathling.fhirpath.Comparable; +import au.csiro.pathling.fhirpath.Comparable.ComparisonOperation; +import au.csiro.pathling.fhirpath.Comparable.SqlComparator; +import au.csiro.pathling.sql.dates.datetime.DateTimeEqualsFunction; +import au.csiro.pathling.sql.dates.datetime.DateTimeGreaterThanFunction; +import au.csiro.pathling.sql.dates.datetime.DateTimeGreaterThanOrEqualToFunction; +import au.csiro.pathling.sql.dates.datetime.DateTimeLessThanFunction; +import au.csiro.pathling.sql.dates.datetime.DateTimeLessThanOrEqualToFunction; +import java.util.function.Function; +import javax.annotation.Nonnull; +import org.apache.spark.sql.Column; + +/** + * Implementation of comparator for the DateTime type. + * + * @author Piotr Szul + */ +public class DateTimeSqlComparator implements SqlComparator { + + private static final DateTimeSqlComparator INSTANCE = new DateTimeSqlComparator(); + + @Override + public Column equalsTo(@Nonnull final Column left, @Nonnull final Column right) { + return callUDF(DateTimeEqualsFunction.FUNCTION_NAME, left, right); + } + + @Override + public Column lessThan(@Nonnull final Column left, @Nonnull final Column right) { + return callUDF(DateTimeLessThanFunction.FUNCTION_NAME, left, right); + } + + @Override + public Column lessThanOrEqual(final Column left, final Column right) { + return callUDF(DateTimeLessThanOrEqualToFunction.FUNCTION_NAME, left, right); + } + + @Override + public Column greaterThan(final Column left, final Column right) { + return callUDF(DateTimeGreaterThanFunction.FUNCTION_NAME, left, right); + } + + @Override + public Column greaterThanOrEqual(final Column left, final Column right) { + return callUDF(DateTimeGreaterThanOrEqualToFunction.FUNCTION_NAME, left, right); + } + + /** + * Builds a comparison function for date and date/time like paths. + * + * @param source the path to build the comparison function for + * @param operation the {@link ComparisonOperation} that should be built + * @return a new {@link Function} + */ + @Nonnull + public static Function buildComparison(@Nonnull final Comparable source, + @Nonnull final ComparisonOperation operation) { + return Comparable.buildComparison(source, operation, INSTANCE); + } +} diff --git a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/comparison/QuantitySqlComparator.java b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/comparison/QuantitySqlComparator.java new file mode 100644 index 0000000000..99ab9a7bf0 --- /dev/null +++ b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/comparison/QuantitySqlComparator.java @@ -0,0 +1,89 @@ +/* + * 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.fhirpath.comparison; + +import static org.apache.spark.sql.functions.when; + +import au.csiro.pathling.fhirpath.Comparable; +import au.csiro.pathling.fhirpath.Comparable.ComparisonOperation; +import au.csiro.pathling.fhirpath.Comparable.SqlComparator; +import au.csiro.pathling.fhirpath.encoding.QuantityEncoding; +import au.csiro.pathling.sql.types.FlexiDecimal; +import java.util.function.BiFunction; +import java.util.function.Function; +import javax.annotation.Nonnull; +import org.apache.spark.sql.Column; + +/** + * Implementation of comparator for the Quantity type. It uses canonicalized values and units for + * comparison rather than the original values. + * + * @author Piotr Szul + */ +public class QuantitySqlComparator implements SqlComparator { + + private final static QuantitySqlComparator INSTANCE = new QuantitySqlComparator(); + + public QuantitySqlComparator() { + } + + private static BiFunction wrap( + @Nonnull final BiFunction function) { + + return (left, right) -> { + final Column sourceCode = left.getField( + QuantityEncoding.CANONICALIZED_CODE_COLUMN); + final Column targetCode = right.getField( + QuantityEncoding.CANONICALIZED_CODE_COLUMN); + final Column sourceValue = left.getField( + QuantityEncoding.CANONICALIZED_VALUE_COLUMN); + final Column targetValue = right.getField( + QuantityEncoding.CANONICALIZED_VALUE_COLUMN); + return when(sourceCode.equalTo(targetCode), + function.apply(sourceValue, targetValue)).otherwise( + null); + }; + } + + @Override + public Column equalsTo(@Nonnull final Column left, @Nonnull final Column right) { + return wrap(FlexiDecimal::equals).apply(left, right); + } + + @Override + public Column lessThan(@Nonnull final Column left, @Nonnull final Column right) { + return wrap(FlexiDecimal::lt).apply(left, right); + } + + @Override + public Column lessThanOrEqual(@Nonnull final Column left, @Nonnull final Column right) { + return wrap(FlexiDecimal::lte).apply(left, right); + } + + @Override + public Column greaterThan(@Nonnull final Column left, @Nonnull final Column right) { + return wrap(FlexiDecimal::gt).apply(left, right); + } + + @Override + public Column greaterThanOrEqual(@Nonnull final Column left, @Nonnull final Column right) { + return wrap(FlexiDecimal::gte).apply(left, right); + } + + /** + * Builds a comparison function for quantity like paths. + * + * @param source the path to build the comparison function for + * @param operation the {@link ComparisonOperation} that should be built + * @return a new {@link Function} + */ + @Nonnull + public static Function buildComparison(@Nonnull final Comparable source, + @Nonnull final ComparisonOperation operation) { + return Comparable.buildComparison(source, operation, INSTANCE); + } +} diff --git a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/element/BooleanPath.java b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/element/BooleanPath.java index 020993e42d..68ea58921a 100644 --- a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/element/BooleanPath.java +++ b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/element/BooleanPath.java @@ -70,7 +70,7 @@ public static ImmutableSet> getComparableTypes() { @Override @Nonnull public Function getComparison(@Nonnull final ComparisonOperation operation) { - return Comparable.buildComparison(this, operation.getSparkFunction()); + return Comparable.buildComparison(this, operation); } @Override diff --git a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/element/CodingPath.java b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/element/CodingPath.java index fcc9c9f00e..ccad81b639 100644 --- a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/element/CodingPath.java +++ b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/element/CodingPath.java @@ -7,27 +7,22 @@ package au.csiro.pathling.fhirpath.element; import static org.apache.spark.sql.functions.callUDF; -import static org.apache.spark.sql.functions.lit; -import au.csiro.pathling.errors.InvalidUserInputError; import au.csiro.pathling.fhirpath.Comparable; import au.csiro.pathling.fhirpath.FhirPath; import au.csiro.pathling.fhirpath.Materializable; import au.csiro.pathling.fhirpath.ResourcePath; +import au.csiro.pathling.fhirpath.comparison.CodingSqlComparator; import au.csiro.pathling.fhirpath.literal.CodingLiteralPath; import au.csiro.pathling.fhirpath.literal.NullLiteralPath; -import au.csiro.pathling.sql.CodingToLiteral; +import au.csiro.pathling.terminology.CodingToLiteral; import com.google.common.collect.ImmutableSet; -import java.util.Arrays; -import java.util.List; import java.util.Optional; -import java.util.function.BiFunction; import java.util.function.Function; import javax.annotation.Nonnull; import org.apache.spark.sql.Column; import org.apache.spark.sql.Dataset; import org.apache.spark.sql.Row; -import org.apache.spark.sql.functions; import org.hl7.fhir.r4.model.Coding; import org.hl7.fhir.r4.model.Enumerations.FHIRDefinedType; @@ -38,10 +33,6 @@ */ public class CodingPath extends ElementPath implements Materializable, Comparable { - private static final List EQUALITY_COLUMNS = Arrays - .asList("system", "code", "version", "display", "userSelected"); - - private static final ImmutableSet> COMPARABLE_TYPES = ImmutableSet .of(CodingPath.class, CodingLiteralPath.class, NullLiteralPath.class); @@ -92,54 +83,15 @@ public static Optional valueFromRow(@Nonnull final Row row, final int co return Optional.of(coding); } - /** - * Builds a comparison function for Coding paths. - * - * @param source The path to build the comparison function for - * @param operation The {@link au.csiro.pathling.fhirpath.Comparable.ComparisonOperation} type to - * build - * @return A new {@link Function} - */ - @Nonnull - public static Function buildComparison(@Nonnull final Comparable source, - @Nonnull final ComparisonOperation operation) { - if (ComparisonOperation.EQUALS.equals(operation)) { - return Comparable - .buildComparison(source, codingEqual()); - } else if (ComparisonOperation.NOT_EQUALS.equals(operation)) { - return Comparable - .buildComparison(source, codingNotEqual()); - } else { - throw new InvalidUserInputError( - "Coding type does not support comparison operator: " + operation); - } - } - - @Nonnull - private static BiFunction codingEqual() { - //noinspection OptionalGetWithoutIsPresent - return (l, r) -> - functions.when(l.isNull().or(r.isNull()), lit(null)) - .otherwise( - EQUALITY_COLUMNS.stream() - .map(f -> l.getField(f).eqNullSafe(r.getField(f))).reduce(Column::and).get() - ); - } - - @Nonnull - private static BiFunction codingNotEqual() { - return codingEqual().andThen(functions::not); - } - @Nonnull public static ImmutableSet> getComparableTypes() { return COMPARABLE_TYPES; } - + @Override @Nonnull public Function getComparison(@Nonnull final ComparisonOperation operation) { - return buildComparison(this, operation); + return CodingSqlComparator.buildComparison(this, operation); } @Override diff --git a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/element/DatePath.java b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/element/DatePath.java index 32b73496dd..30e8898ade 100644 --- a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/element/DatePath.java +++ b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/element/DatePath.java @@ -6,16 +6,20 @@ package au.csiro.pathling.fhirpath.element; +import static au.csiro.pathling.fhirpath.Temporal.buildDateArithmeticOperation; import static org.apache.spark.sql.functions.to_timestamp; import au.csiro.pathling.fhirpath.Comparable; import au.csiro.pathling.fhirpath.FhirPath; import au.csiro.pathling.fhirpath.Materializable; +import au.csiro.pathling.fhirpath.Numeric.MathOperation; import au.csiro.pathling.fhirpath.ResourcePath; +import au.csiro.pathling.fhirpath.Temporal; +import au.csiro.pathling.fhirpath.comparison.DateTimeSqlComparator; import au.csiro.pathling.fhirpath.literal.DateLiteralPath; -import java.text.ParseException; -import java.text.SimpleDateFormat; -import java.util.Date; +import au.csiro.pathling.fhirpath.literal.QuantityLiteralPath; +import au.csiro.pathling.sql.dates.date.DateAddDurationFunction; +import au.csiro.pathling.sql.dates.date.DateSubtractDurationFunction; import java.util.Optional; import java.util.function.BiFunction; import java.util.function.Function; @@ -33,26 +37,8 @@ * @author John Grimes */ @Slf4j -public class DatePath extends ElementPath implements Materializable, Comparable { - - private static final ThreadLocal FULL_DATE_FORMAT = ThreadLocal - .withInitial(() -> { - final SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd"); - format.setTimeZone(DateTimePath.getTimeZone()); - return format; - }); - private static final ThreadLocal YEAR_MONTH_DATE_FORMAT = ThreadLocal - .withInitial(() -> { - final SimpleDateFormat format = new SimpleDateFormat("yyyy-MM"); - format.setTimeZone(DateTimePath.getTimeZone()); - return format; - }); - private static final ThreadLocal YEAR_ONLY_DATE_FORMAT = ThreadLocal - .withInitial(() -> { - final SimpleDateFormat format = new SimpleDateFormat("yyyy"); - format.setTimeZone(DateTimePath.getTimeZone()); - return format; - }); +public class DatePath extends ElementPath implements Materializable, Comparable, + Temporal { protected DatePath(@Nonnull final String expression, @Nonnull final Dataset dataset, @Nonnull final Column idColumn, @Nonnull final Optional eidColumn, @@ -79,18 +65,6 @@ public static Function buildComparison(@Nonnull final Compar to_timestamp(target.getValueColumn())); } - public static SimpleDateFormat getFullDateFormat() { - return FULL_DATE_FORMAT.get(); - } - - public static SimpleDateFormat getYearMonthDateFormat() { - return YEAR_MONTH_DATE_FORMAT.get(); - } - - public static SimpleDateFormat getYearOnlyDateFormat() { - return YEAR_ONLY_DATE_FORMAT.get(); - } - @Nonnull @Override public Optional getValueFromRow(@Nonnull final Row row, final int columnNumber) { @@ -109,20 +83,14 @@ public static Optional valueFromRow(@Nonnull final Row row, final int if (row.isNullAt(columnNumber)) { return Optional.empty(); } - final Date date; - try { - date = getFullDateFormat().parse(row.getString(columnNumber)); - } catch (final ParseException e) { - log.warn("Error parsing date extracted from row", e); - return Optional.empty(); - } - return Optional.of(new DateType(date)); + final String dateString = row.getString(columnNumber); + return Optional.of(new DateType(dateString)); } @Override @Nonnull public Function getComparison(@Nonnull final ComparisonOperation operation) { - return DateTimePath.buildComparison(this, operation.getSparkFunction()); + return DateTimeSqlComparator.buildComparison(this, operation); } @Override @@ -134,4 +102,14 @@ public boolean isComparableTo(@Nonnull final Class type) { public boolean canBeCombinedWith(@Nonnull final FhirPath target) { return super.canBeCombinedWith(target) || target instanceof DateLiteralPath; } + + @Nonnull + @Override + public Function getDateArithmeticOperation( + @Nonnull final MathOperation operation, @Nonnull final Dataset dataset, + @Nonnull final String expression) { + return buildDateArithmeticOperation(this, operation, dataset, expression, + DateAddDurationFunction.FUNCTION_NAME, DateSubtractDurationFunction.FUNCTION_NAME); + } + } diff --git a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/element/DateTimePath.java b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/element/DateTimePath.java index e741b16d3c..b87b23100c 100644 --- a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/element/DateTimePath.java +++ b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/element/DateTimePath.java @@ -6,20 +6,24 @@ package au.csiro.pathling.fhirpath.element; -import static org.apache.spark.sql.functions.to_timestamp; +import static au.csiro.pathling.fhirpath.Temporal.buildDateArithmeticOperation; +import static org.apache.spark.sql.functions.callUDF; import au.csiro.pathling.fhirpath.Comparable; import au.csiro.pathling.fhirpath.FhirPath; import au.csiro.pathling.fhirpath.Materializable; +import au.csiro.pathling.fhirpath.Numeric.MathOperation; import au.csiro.pathling.fhirpath.ResourcePath; +import au.csiro.pathling.fhirpath.Temporal; +import au.csiro.pathling.fhirpath.comparison.DateTimeSqlComparator; import au.csiro.pathling.fhirpath.literal.DateLiteralPath; import au.csiro.pathling.fhirpath.literal.DateTimeLiteralPath; import au.csiro.pathling.fhirpath.literal.NullLiteralPath; +import au.csiro.pathling.fhirpath.literal.QuantityLiteralPath; +import au.csiro.pathling.sql.dates.datetime.DateTimeAddDurationFunction; +import au.csiro.pathling.sql.dates.datetime.DateTimeSubtractDurationFunction; import com.google.common.collect.ImmutableSet; -import java.text.SimpleDateFormat; import java.util.Optional; -import java.util.TimeZone; -import java.util.function.BiFunction; import java.util.function.Function; import javax.annotation.Nonnull; import org.apache.spark.sql.Column; @@ -36,15 +40,7 @@ * @author John Grimes */ public class DateTimePath extends ElementPath implements Materializable, - Comparable { - - private static final TimeZone TIME_ZONE = TimeZone.getTimeZone("GMT"); - private static final ThreadLocal DATE_FORMAT = ThreadLocal - .withInitial(() -> { - final SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssXXX"); - format.setTimeZone(TIME_ZONE); - return format; - }); + Comparable, Temporal { private static final ImmutableSet> COMPARABLE_TYPES = ImmutableSet .of(DatePath.class, DateTimePath.class, DateLiteralPath.class, DateTimeLiteralPath.class, @@ -80,43 +76,15 @@ public static Optional valueFromRow(@Nonnull final Row row, if (row.isNullAt(columnNumber)) { return Optional.empty(); } - if (fhirType == FHIRDefinedType.INSTANT) { final InstantType value = new InstantType(row.getTimestamp(columnNumber)); - value.setTimeZone(TIME_ZONE); return Optional.of(value); } else { final DateTimeType value = new DateTimeType(row.getString(columnNumber)); - value.setTimeZone(TIME_ZONE); return Optional.of(value); } } - /** - * Builds a comparison function for date and date/time like paths. - * - * @param source The path to build the comparison function for - * @param sparkFunction The Spark column function to use - * @return A new {@link Function} - */ - @Nonnull - public static Function buildComparison(@Nonnull final Comparable source, - @Nonnull final BiFunction sparkFunction) { - // The value columns are converted to native Spark timestamps before comparison. The reason that - // we don't use an explicit format string here is that we require flexibility to accommodate the - // optionality of the milliseconds component of the FHIR date time format. - return target -> sparkFunction - .apply(to_timestamp(source.getValueColumn()), to_timestamp(target.getValueColumn())); - } - - public static SimpleDateFormat getDateFormat() { - return DATE_FORMAT.get(); - } - - public static TimeZone getTimeZone() { - return TIME_ZONE; - } - @Nonnull public static ImmutableSet> getComparableTypes() { return COMPARABLE_TYPES; @@ -125,7 +93,7 @@ public static ImmutableSet> getComparableTypes() { @Override @Nonnull public Function getComparison(@Nonnull final ComparisonOperation operation) { - return buildComparison(this, operation.getSparkFunction()); + return DateTimeSqlComparator.buildComparison(this, operation); } @Override @@ -137,4 +105,14 @@ public boolean isComparableTo(@Nonnull final Class type) { public boolean canBeCombinedWith(@Nonnull final FhirPath target) { return super.canBeCombinedWith(target) || target instanceof DateTimeLiteralPath; } + + @Nonnull + @Override + public Function getDateArithmeticOperation( + @Nonnull final MathOperation operation, @Nonnull final Dataset dataset, + @Nonnull final String expression) { + return buildDateArithmeticOperation(this, operation, dataset, expression, + DateTimeAddDurationFunction.FUNCTION_NAME, DateTimeSubtractDurationFunction.FUNCTION_NAME); + } + } diff --git a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/element/DecimalPath.java b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/element/DecimalPath.java index 5118f4af5d..b3c41cfdf2 100644 --- a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/element/DecimalPath.java +++ b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/element/DecimalPath.java @@ -15,7 +15,6 @@ import au.csiro.pathling.fhirpath.Numeric; import au.csiro.pathling.fhirpath.ResourcePath; import au.csiro.pathling.fhirpath.literal.DecimalLiteralPath; -import au.csiro.pathling.fhirpath.literal.IntegerLiteralPath; import java.math.BigDecimal; import java.math.RoundingMode; import java.util.Optional; @@ -34,7 +33,6 @@ * * @author John Grimes */ -@SuppressWarnings("NullableProblems") public class DecimalPath extends ElementPath implements Materializable, Comparable, Numeric { @@ -93,7 +91,7 @@ public static Optional valueFromRow(@Nonnull final Row row, final i @Override @Nonnull public Function getComparison(@Nonnull final ComparisonOperation operation) { - return Comparable.buildComparison(this, operation.getSparkFunction()); + return Comparable.buildComparison(this, operation); } public static org.apache.spark.sql.types.DecimalType getDecimalType() { @@ -109,31 +107,38 @@ public boolean isComparableTo(@Nonnull final Class type) { @Override public Function getMathOperation(@Nonnull final MathOperation operation, @Nonnull final String expression, @Nonnull final Dataset dataset) { - return buildMathOperation(this, operation, expression, dataset, getFhirType()); + return buildMathOperation(this, operation, expression, dataset); + } + + @Nonnull + @Override + public Column getNumericValueColumn() { + return getValueColumn(); + } + + @Nonnull + @Override + public Column getNumericContextColumn() { + return getNumericValueColumn(); } /** * Builds a math operation result for a Decimal-like path. * - * @param source The left operand for the operation - * @param operation The type of {@link au.csiro.pathling.fhirpath.Numeric.MathOperation} - * @param expression The FHIRPath expression to use in the result - * @param dataset The {@link Dataset} to use in the result - * @param fhirType The {@link FHIRDefinedType} to use in the result + * @param source the left operand for the operation + * @param operation the type of {@link au.csiro.pathling.fhirpath.Numeric.MathOperation} + * @param expression the FHIRPath expression to use in the result + * @param dataset the {@link Dataset} to use in the result * @return A {@link Function} that takes a {@link Numeric} as a parameter, and returns a * {@link NonLiteralPath} */ @Nonnull public static Function buildMathOperation(@Nonnull final Numeric source, @Nonnull final MathOperation operation, @Nonnull final String expression, - @Nonnull final Dataset dataset, @Nonnull final FHIRDefinedType fhirType) { + @Nonnull final Dataset dataset) { return target -> { - final Column targetValueColumn = - target instanceof IntegerPath || target instanceof IntegerLiteralPath - ? target.getValueColumn().cast(DataTypes.LongType) - : target.getValueColumn(); Column valueColumn = operation.getSparkFunction() - .apply(source.getValueColumn(), targetValueColumn); + .apply(source.getNumericValueColumn(), target.getNumericValueColumn()); final Column idColumn = source.getIdColumn(); final Optional eidColumn = findEidColumn(source, target); final Optional thisColumn = findThisColumn(source, target); @@ -146,7 +151,7 @@ public static Function buildMathOperation(@Nonnull fina valueColumn = valueColumn.cast(getDecimalType()); return ElementPath .build(expression, dataset, idColumn, eidColumn, valueColumn, true, Optional.empty(), - thisColumn, fhirType); + thisColumn, source.getFhirType()); case MODULUS: valueColumn = valueColumn.cast(DataTypes.LongType); return ElementPath diff --git a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/element/ElementDefinition.java b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/element/ElementDefinition.java index 5d6eef2ff9..fcf22b777a 100644 --- a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/element/ElementDefinition.java +++ b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/element/ElementDefinition.java @@ -55,6 +55,7 @@ public class ElementDefinition { .put(FHIRDefinedType.TIME, TimePath.class) .put(FHIRDefinedType.CODING, CodingPath.class) .put(FHIRDefinedType.QUANTITY, QuantityPath.class) + .put(FHIRDefinedType.SIMPLEQUANTITY, QuantityPath.class) .put(FHIRDefinedType.REFERENCE, ReferencePath.class) .put(FHIRDefinedType.EXTENSION, ExtensionPath.class) .build(); diff --git a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/element/IntegerPath.java b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/element/IntegerPath.java index 5e06b31787..f27fa48434 100644 --- a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/element/IntegerPath.java +++ b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/element/IntegerPath.java @@ -106,7 +106,7 @@ public static ImmutableSet> getComparableTypes() { @Override @Nonnull public Function getComparison(@Nonnull final ComparisonOperation operation) { - return Comparable.buildComparison(this, operation.getSparkFunction()); + return Comparable.buildComparison(this, operation); } @Override @@ -118,7 +118,19 @@ public boolean isComparableTo(@Nonnull final Class type) { @Override public Function getMathOperation(@Nonnull final MathOperation operation, @Nonnull final String expression, @Nonnull final Dataset dataset) { - return buildMathOperation(this, operation, expression, dataset, getFhirType()); + return buildMathOperation(this, operation, expression, dataset); + } + + @Nonnull + @Override + public Column getNumericValueColumn() { + return getValueColumn().cast(DataTypes.LongType); + } + + @Nonnull + @Override + public Column getNumericContextColumn() { + return getNumericValueColumn(); } /** @@ -128,21 +140,17 @@ public Function getMathOperation(@Nonnull final MathOpe * @param operation The type of {@link au.csiro.pathling.fhirpath.Numeric.MathOperation} * @param expression The FHIRPath expression to use in the result * @param dataset The {@link Dataset} to use in the result - * @param fhirType The {@link FHIRDefinedType} to use in the result - * @return A {@link Function} that takes a {@link Numeric} as a parameter, and returns a - * {@link NonLiteralPath} + * @return A {@link Function} that takes a {@link Numeric} as a parameter, and returns a {@link + * NonLiteralPath} */ @Nonnull public static Function buildMathOperation(@Nonnull final Numeric source, @Nonnull final MathOperation operation, @Nonnull final String expression, - @Nonnull final Dataset dataset, @Nonnull final FHIRDefinedType fhirType) { + @Nonnull final Dataset dataset) { return target -> { - final Column targetValueColumn = - target instanceof IntegerPath || target instanceof IntegerLiteralPath - ? target.getValueColumn().cast(DataTypes.LongType) - : target.getValueColumn(); + final Column targetValueColumn = target.getNumericValueColumn(); Column valueColumn = operation.getSparkFunction() - .apply(source.getValueColumn().cast(DataTypes.LongType), targetValueColumn); + .apply(source.getNumericValueColumn(), targetValueColumn); final Column idColumn = source.getIdColumn(); final Optional eidColumn = findEidColumn(source, target); final Optional thisColumn = findThisColumn(source, target); @@ -157,7 +165,7 @@ public static Function buildMathOperation(@Nonnull fina } return ElementPath .build(expression, dataset, idColumn, eidColumn, valueColumn, true, Optional.empty(), - thisColumn, fhirType); + thisColumn, source.getFhirType()); case DIVISION: final Column numerator = source.getValueColumn().cast(DecimalPath.getDecimalType()); valueColumn = operation.getSparkFunction().apply(numerator, targetValueColumn); diff --git a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/element/QuantityPath.java b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/element/QuantityPath.java index 6015caca44..6dccf18459 100644 --- a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/element/QuantityPath.java +++ b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/element/QuantityPath.java @@ -6,8 +6,23 @@ package au.csiro.pathling.fhirpath.element; +import static org.apache.spark.sql.functions.lit; +import static org.apache.spark.sql.functions.when; + +import au.csiro.pathling.encoders.terminology.ucum.Ucum; +import au.csiro.pathling.fhirpath.Comparable; +import au.csiro.pathling.fhirpath.NonLiteralPath; +import au.csiro.pathling.fhirpath.Numeric; import au.csiro.pathling.fhirpath.ResourcePath; +import au.csiro.pathling.fhirpath.comparison.QuantitySqlComparator; +import au.csiro.pathling.fhirpath.encoding.QuantityEncoding; +import au.csiro.pathling.fhirpath.literal.NullLiteralPath; +import au.csiro.pathling.fhirpath.literal.QuantityLiteralPath; +import au.csiro.pathling.sql.types.FlexiDecimal; +import com.google.common.collect.ImmutableSet; import java.util.Optional; +import java.util.function.BiFunction; +import java.util.function.Function; import javax.annotation.Nonnull; import org.apache.spark.sql.Column; import org.apache.spark.sql.Dataset; @@ -19,7 +34,10 @@ * * @author John Grimes */ -public class QuantityPath extends ElementPath { +public class QuantityPath extends ElementPath implements Comparable, Numeric { + + public static final ImmutableSet> COMPARABLE_TYPES = ImmutableSet + .of(QuantityPath.class, QuantityLiteralPath.class, NullLiteralPath.class); protected QuantityPath(@Nonnull final String expression, @Nonnull final Dataset dataset, @Nonnull final Column idColumn, @Nonnull final Optional eidColumn, @@ -30,4 +48,151 @@ protected QuantityPath(@Nonnull final String expression, @Nonnull final Dataset< thisColumn, fhirType); } + @Nonnull + @Override + public Function getComparison(@Nonnull final ComparisonOperation operation) { + return QuantitySqlComparator.buildComparison(this, operation); + } + + @Override + public boolean isComparableTo(@Nonnull final Class type) { + return COMPARABLE_TYPES.contains(type); + } + + @Nonnull + @Override + public Column getNumericValueColumn() { + return getValueColumn().getField(QuantityEncoding.CANONICALIZED_VALUE_COLUMN); + } + + @Nonnull + @Override + public Column getNumericContextColumn() { + return getValueColumn(); + } + + @Nonnull + @Override + public Function getMathOperation(@Nonnull final MathOperation operation, + @Nonnull final String expression, @Nonnull final Dataset dataset) { + return buildMathOperation(this, operation, expression, dataset, getDefinition()); + } + + @Nonnull + private static BiFunction getMathOperation( + @Nonnull final MathOperation operation) { + switch (operation) { + case ADDITION: + return FlexiDecimal::plus; + case MULTIPLICATION: + return FlexiDecimal::multiply; + case DIVISION: + return FlexiDecimal::divide; + case SUBTRACTION: + return FlexiDecimal::minus; + default: + throw new AssertionError("Unsupported math operation encountered: " + operation); + } + } + + private static final Column NO_UNIT_LITERAL = lit(Ucum.NO_UNIT_CODE); + + @Nonnull + private static Column getResultUnit( + @Nonnull final MathOperation operation, @Nonnull final Column leftUnit, + @Nonnull final Column rightUnit) { + switch (operation) { + case ADDITION: + case SUBTRACTION: + return leftUnit; + case MULTIPLICATION: + // we only allow multiplication by dimensionless values at the moment + // the unit is preserved in this case + return when(leftUnit.notEqual(NO_UNIT_LITERAL), leftUnit).otherwise(rightUnit); + case DIVISION: + // we only allow division by the same unit or a dimensionless value + return when(leftUnit.equalTo(rightUnit), NO_UNIT_LITERAL).otherwise(leftUnit); + default: + throw new AssertionError("Unsupported math operation encountered: " + operation); + } + } + + @Nonnull + private static Column getValidResult( + @Nonnull final MathOperation operation, @Nonnull final Column result, + @Nonnull final Column leftUnit, + @Nonnull final Column rightUnit) { + switch (operation) { + case ADDITION: + case SUBTRACTION: + return when(leftUnit.equalTo(rightUnit), result) + .otherwise(null); + case MULTIPLICATION: + // we only allow multiplication by dimensionless values at the moment + // the unit is preserved in this case + return when(leftUnit.equalTo(NO_UNIT_LITERAL).or(rightUnit.equalTo(NO_UNIT_LITERAL)), + result).otherwise(null); + case DIVISION: + // we only allow division by the same unit or a dimensionless value + return when(leftUnit.equalTo(rightUnit).or(rightUnit.equalTo(NO_UNIT_LITERAL)), + result).otherwise(null); + default: + throw new AssertionError("Unsupported math operation encountered: " + operation); + } + } + + @Nonnull + public static Function buildMathOperation(@Nonnull final Numeric source, + @Nonnull final MathOperation operation, @Nonnull final String expression, + @Nonnull final Dataset dataset, + @Nonnull final Optional elementDefinition) { + return target -> { + final BiFunction mathOperation = getMathOperation(operation); + final Column sourceComparable = source.getNumericValueColumn(); + final Column sourceContext = source.getNumericContextColumn(); + final Column targetContext = target.getNumericContextColumn(); + final Column resultColumn = mathOperation + .apply(sourceComparable, target.getNumericValueColumn()); + final Column sourceCanonicalizedCode = sourceContext.getField( + QuantityEncoding.CANONICALIZED_CODE_COLUMN); + final Column targetCanonicalizedCode = targetContext.getField( + QuantityEncoding.CANONICALIZED_CODE_COLUMN); + final Column resultCode = getResultUnit(operation, sourceCanonicalizedCode, + targetCanonicalizedCode); + + final Column resultStruct = QuantityEncoding.toStruct( + sourceContext.getField("id"), + FlexiDecimal.toDecimal(resultColumn), + // NOTE: This (setting value_scale to null) works because we never decode this struct to a Quantity. + // The only Quantities that are decoded are calendar duration quantities parsed from literals. + lit(null), + sourceContext.getField("comparator"), + resultCode, + sourceContext.getField("system"), + resultCode, + resultColumn, + resultCode, + sourceContext.getField("_fid") + ); + + final Column validResult = getValidResult(operation, resultStruct, + sourceCanonicalizedCode, targetCanonicalizedCode); + final Column resultQuantityColumn = when(sourceContext.isNull().or(targetContext.isNull()), + null).otherwise(validResult); + + final Column idColumn = source.getIdColumn(); + final Optional eidColumn = findEidColumn(source, target); + final Optional thisColumn = findThisColumn(source, target); + return + elementDefinition.map(definition -> ElementPath + .build(expression, dataset, idColumn, eidColumn, resultQuantityColumn, true, + Optional.empty(), + thisColumn, definition)).orElseGet(() -> ElementPath + .build(expression, dataset, idColumn, eidColumn, resultQuantityColumn, true, + Optional.empty(), + thisColumn, FHIRDefinedType.QUANTITY)); + + }; + } + } diff --git a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/element/StringPath.java b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/element/StringPath.java index 9acb81ed8d..73b484c39e 100644 --- a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/element/StringPath.java +++ b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/element/StringPath.java @@ -98,7 +98,7 @@ public static ImmutableSet> getComparableTypes() { @Override @Nonnull public Function getComparison(@Nonnull final ComparisonOperation operation) { - return Comparable.buildComparison(this, operation.getSparkFunction()); + return Comparable.buildComparison(this, operation); } @Override diff --git a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/element/TimePath.java b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/element/TimePath.java index c2f4e25952..eedf4bb267 100644 --- a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/element/TimePath.java +++ b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/element/TimePath.java @@ -70,7 +70,7 @@ public static ImmutableSet> getComparableTypes() { @Override @Nonnull public Function getComparison(@Nonnull final ComparisonOperation operation) { - return Comparable.buildComparison(this, operation.getSparkFunction()); + return Comparable.buildComparison(this, operation); } @Override diff --git a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/encoding/QuantityEncoding.java b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/encoding/QuantityEncoding.java new file mode 100644 index 0000000000..dddc99ba57 --- /dev/null +++ b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/encoding/QuantityEncoding.java @@ -0,0 +1,256 @@ +/* + * 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.fhirpath.encoding; + +import static org.apache.spark.sql.functions.lit; +import static org.apache.spark.sql.functions.struct; + +import au.csiro.pathling.encoders.QuantitySupport; +import au.csiro.pathling.encoders.datatypes.DecimalCustomCoder; +import au.csiro.pathling.encoders.terminology.ucum.Ucum; +import au.csiro.pathling.fhirpath.CalendarDurationUtils; +import au.csiro.pathling.sql.types.FlexiDecimal; +import au.csiro.pathling.sql.types.FlexiDecimalSupport; +import com.google.common.collect.ImmutableMap; +import java.math.BigDecimal; +import java.math.RoundingMode; +import java.util.Map; +import java.util.Optional; +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.types.DataTypes; +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; +import org.hl7.fhir.r4.model.Quantity; +import org.hl7.fhir.r4.model.Quantity.QuantityComparator; + +/** + * Object decoders/encoders for {@link Quantity}. + * + * @author Piotr Szul + */ +public final class QuantityEncoding { + + private QuantityEncoding() { + // Utility class + } + + private static final Map CALENDAR_DURATION_TO_UCUM = new ImmutableMap.Builder() + .put("second", "s") + .put("seconds", "s") + .put("millisecond", "ms") + .put("milliseconds", "ms") + .build(); + + public static final String CANONICALIZED_VALUE_COLUMN = QuantitySupport + .VALUE_CANONICALIZED_FIELD_NAME(); + public static final String CANONICALIZED_CODE_COLUMN = QuantitySupport + .CODE_CANONICALIZED_FIELD_NAME(); + + + /** + * Encodes a Quantity to a Row (spark SQL compatible type) + * + * @param quantity a coding to encode + * @param includeScale whether the scale of the value should be encoded (or set to null) + * @return the Row representation of the quantity + */ + @Nullable + public static Row encode(@Nullable final Quantity quantity, final boolean includeScale) { + if (quantity == null) { + return null; + } + final BigDecimal value = quantity.getValue(); + @Nullable final String code = quantity.getCode(); + final BigDecimal canonicalizedValue; + final String canonicalizedCode; + if (quantity.getSystem().equals(Ucum.SYSTEM_URI)) { + canonicalizedValue = Ucum.getCanonicalValue(value, code); + canonicalizedCode = Ucum.getCanonicalCode(value, code); + } else { + canonicalizedValue = null; + canonicalizedCode = null; + } + final String comparator = Optional.ofNullable(quantity.getComparator()) + .map(QuantityComparator::toCode).orElse(null); + return RowFactory.create(quantity.getId(), + quantity.getValue(), + // We cannot encode the scale of the results of arithmetic operations. + includeScale + ? quantity.getValue().scale() + : null, + comparator, + quantity.getUnit(), quantity.getSystem(), quantity.getCode(), + FlexiDecimal.toValue(canonicalizedValue), + canonicalizedCode, null /* _fid */); + } + + /** + * Encodes a Quantity to a Row (spark SQL compatible type) + * + * @param quantity a coding to encode + * @return the Row representation of the quantity + */ + @Nullable + public static Row encode(@Nullable final Quantity quantity) { + return encode(quantity, true); + } + + /** + * Decodes a Quantity from a Row. + * + * @param row the row to decode + * @return the resulting Quantity + */ + @Nonnull + public static Quantity decode(@Nonnull final Row row) { + final Quantity quantity = new Quantity(); + + Optional.ofNullable(row.getString(0)).ifPresent(quantity::setId); + + // The value gets converted to a BigDecimal, taking into account the scale that has been encoded + // alongside it. + final int scale = row.getInt(2); + final BigDecimal value = Optional.ofNullable(row.getDecimal(1)) + .map(bd -> bd.scale() > DecimalCustomCoder.scale() + ? bd.setScale(scale, RoundingMode.HALF_UP) + : bd) + .orElse(null); + quantity.setValue(value); + + // The comparator is encoded as a string code, we need to convert it back to an enum. + Optional.ofNullable(row.getString(3)) + .map(QuantityComparator::fromCode) + .ifPresent(quantity::setComparator); + + Optional.ofNullable(row.getString(4)).ifPresent(quantity::setUnit); + Optional.ofNullable(row.getString(5)).ifPresent(quantity::setSystem); + Optional.ofNullable(row.getString(6)).ifPresent(quantity::setCode); + + return quantity; + } + + + /** + * A {@link StructType} for a Quantity. + */ + @Nonnull + public static StructType dataType() { + final Metadata metadata = new MetadataBuilder().build(); + final StructField id = new StructField("id", DataTypes.StringType, true, metadata); + final StructField value = new StructField("value", DataTypes.createDecimalType( + DecimalCustomCoder.precision(), DecimalCustomCoder.scale()), true, metadata); + final StructField valueScale = new StructField("value_scale", DataTypes.IntegerType, true, + metadata); + final StructField comparator = new StructField("comparator", DataTypes.StringType, true, + metadata); + final StructField unit = new StructField("unit", DataTypes.StringType, true, metadata); + final StructField system = new StructField("system", DataTypes.StringType, true, metadata); + final StructField code = new StructField("code", DataTypes.StringType, true, metadata); + final StructField canonicalizedValue = new StructField(CANONICALIZED_VALUE_COLUMN, + FlexiDecimal.DATA_TYPE, true, metadata); + final StructField canonicalizedCode = new StructField(CANONICALIZED_CODE_COLUMN, + DataTypes.StringType, true, metadata); + final StructField fid = new StructField("_fid", DataTypes.IntegerType, true, + metadata); + return new StructType( + new StructField[]{id, value, valueScale, comparator, unit, system, code, canonicalizedValue, + canonicalizedCode, fid}); + } + + /** + * Creates the structure representing the quantity column from its fields. + * + * @param id the id column + * @param value the value column + * @param value_scale the scale of the value column + * @param comparator the comparator column + * @param unit the unit column + * @param system the system column + * @param code the code column + * @param canonicalizedValue the canonicalized value column + * @param canonicalizedCode the canonicalized code column + * @param _fid the _fid column + * @return the SQL struct for the Quantity type. + */ + @Nonnull + public static Column toStruct( + @Nonnull final Column id, + @Nonnull final Column value, + @Nonnull final Column value_scale, + @Nonnull final Column comparator, + @Nonnull final Column unit, + @Nonnull final Column system, + @Nonnull final Column code, + @Nonnull final Column canonicalizedValue, + @Nonnull final Column canonicalizedCode, + @Nonnull final Column _fid + ) { + return struct( + id.as("id"), + value.cast(DecimalCustomCoder.decimalType()).as("value"), + value_scale.as("value_scale"), + comparator.as("comparator"), + unit.as("unit"), + system.as("system"), + code.as("code"), + canonicalizedValue.as(CANONICALIZED_VALUE_COLUMN), + canonicalizedCode.as(CANONICALIZED_CODE_COLUMN), + _fid.as("_fid") + ); + } + + /** + * Encodes the quantity as a literal column that includes appropriate canonicalization. + * + * @param quantity the quantity to encode. + * @return the column with the literal representation of the quantity. + */ + @Nonnull + public static Column encodeLiteral(@Nonnull final Quantity quantity) { + final Optional comparator = Optional.ofNullable(quantity.getComparator()); + final BigDecimal value = quantity.getValue(); + + final BigDecimal canonicalizedValue; + final String canonicalizedCode; + if (quantity.getSystem().equals(Ucum.SYSTEM_URI)) { + // If it is a UCUM Quantity, use the UCUM library to canonicalize the value and code. + canonicalizedValue = Ucum.getCanonicalValue(value, quantity.getCode()); + canonicalizedCode = Ucum.getCanonicalCode(value, quantity.getCode()); + } else if (CalendarDurationUtils.isCalendarDuration(quantity) && + CALENDAR_DURATION_TO_UCUM.containsKey(quantity.getCode())) { + // If it is a (supported) calendar duration, get the corresponding UCUM unit and then use the + // UCUM library to canonicalize the value and code. + final String resolvedCode = CALENDAR_DURATION_TO_UCUM.get(quantity.getCode()); + canonicalizedValue = Ucum.getCanonicalValue(value, resolvedCode); + canonicalizedCode = Ucum.getCanonicalCode(value, resolvedCode); + } else { + // If it is neither a UCUM Quantity nor a calendar duration, it will not have a canonicalized + // form available. + canonicalizedValue = null; + canonicalizedCode = null; + } + + return toStruct( + lit(quantity.getId()), + lit(value), + lit(value.scale()), + lit(comparator.map(QuantityComparator::toCode).orElse(null)), + lit(quantity.getUnit()), + lit(quantity.getSystem()), + lit(quantity.getCode()), + FlexiDecimalSupport.toLiteral(canonicalizedValue), + lit(canonicalizedCode), + lit(null)); + } + +} diff --git a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/function/NamedFunction.java b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/function/NamedFunction.java index cb379a8cb1..d2b7a83ccb 100644 --- a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/function/NamedFunction.java +++ b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/function/NamedFunction.java @@ -51,6 +51,7 @@ public interface NamedFunction { .put("allTrue", new BooleansTestFunction(ALL_TRUE)) .put("allFalse", new BooleansTestFunction(ALL_FALSE)) .put("extension", new ExtensionFunction()) + .put("until", new UntilFunction()) .build(); /** diff --git a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/function/UntilFunction.java b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/function/UntilFunction.java new file mode 100644 index 0000000000..fa56b0832f --- /dev/null +++ b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/function/UntilFunction.java @@ -0,0 +1,85 @@ +/* + * 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.fhirpath.function; + +import static au.csiro.pathling.QueryHelpers.join; +import static au.csiro.pathling.fhirpath.NonLiteralPath.findEidColumn; +import static au.csiro.pathling.fhirpath.NonLiteralPath.findThisColumn; +import static au.csiro.pathling.utilities.Preconditions.checkUserInput; +import static org.apache.spark.sql.functions.callUDF; + +import au.csiro.pathling.QueryHelpers.JoinType; +import au.csiro.pathling.fhirpath.FhirPath; +import au.csiro.pathling.fhirpath.NonLiteralPath; +import au.csiro.pathling.fhirpath.element.DatePath; +import au.csiro.pathling.fhirpath.element.DateTimePath; +import au.csiro.pathling.fhirpath.element.ElementPath; +import au.csiro.pathling.fhirpath.literal.DateLiteralPath; +import au.csiro.pathling.fhirpath.literal.DateTimeLiteralPath; +import au.csiro.pathling.fhirpath.literal.StringLiteralPath; +import au.csiro.pathling.sql.dates.TemporalDifferenceFunction; +import javax.annotation.Nonnull; +import org.apache.spark.sql.Column; +import org.apache.spark.sql.Dataset; +import org.apache.spark.sql.Row; +import org.hl7.fhir.r4.model.Enumerations.FHIRDefinedType; +import java.util.Optional; + +/** + * This function computes the time interval (duration) between two paths representing dates or dates + * with time. + * + * @author John Grimes + * @see until + */ +public class UntilFunction implements NamedFunction { + + private static final String NAME = "until"; + + @Nonnull + @Override + public FhirPath invoke(@Nonnull final NamedFunctionInput input) { + checkUserInput(input.getArguments().size() == 2, + "until function must have two arguments"); + final NonLiteralPath fromArgument = input.getInput(); + final FhirPath toArgument = input.getArguments().get(0); + final FhirPath calendarDurationArgument = input.getArguments().get(1); + + checkUserInput(fromArgument instanceof DateTimePath || fromArgument instanceof DatePath, + "until function must be invoked on a DateTime or Date"); + checkUserInput(toArgument instanceof DateTimePath || toArgument instanceof DateTimeLiteralPath + || toArgument instanceof DatePath || toArgument instanceof DateLiteralPath, + "until function must have a DateTime or Date as the first argument"); + + checkUserInput(fromArgument.isSingular(), + "until function must be invoked on a singular path"); + checkUserInput(toArgument.isSingular(), + "until function must have the singular path as its first argument"); + + checkUserInput(calendarDurationArgument instanceof StringLiteralPath, + "until function must have a String as the second argument"); + final String literalValue = ((StringLiteralPath) calendarDurationArgument).getValue() + .asStringValue(); + checkUserInput(TemporalDifferenceFunction.isValidCalendarDuration(literalValue), + "Invalid calendar duration: " + literalValue); + + final Dataset dataset = join(input.getContext(), fromArgument, toArgument, + JoinType.LEFT_OUTER); + final Column valueColumn = callUDF(TemporalDifferenceFunction.FUNCTION_NAME, + fromArgument.getValueColumn(), toArgument.getValueColumn(), + calendarDurationArgument.getValueColumn()); + final String expression = NamedFunction.expressionFromInput(input, NAME); + + final Optional eidColumn = findEidColumn(fromArgument, toArgument); + final Optional thisColumn = findThisColumn(fromArgument, toArgument); + + return ElementPath.build(expression, dataset, fromArgument.getIdColumn(), + eidColumn, valueColumn, true, + fromArgument.getCurrentResource(), thisColumn, FHIRDefinedType.INTEGER); + } + +} diff --git a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/function/memberof/MemberOfFunction.java b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/function/memberof/MemberOfFunction.java index 1d0dd07063..1aab516a46 100644 --- a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/function/memberof/MemberOfFunction.java +++ b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/function/memberof/MemberOfFunction.java @@ -71,7 +71,7 @@ public FhirPath invoke(@Nonnull final NamedFunctionInput input) { // Serializable. final TerminologyServiceFactory terminologyServiceFactory = checkPresent(inputContext.getTerminologyServiceFactory()); - final String valueSetUri = argument.getJavaValue(); + final String valueSetUri = argument.getValue().getValueAsString(); final Dataset dataset = inputPath.getDataset(); final Dataset resultDataset = TerminologyFunctions.memberOf(codingArrayCol, valueSetUri, diff --git a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/function/translate/TranslateFunction.java b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/function/translate/TranslateFunction.java index 18e031624d..6d4632f8d5 100644 --- a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/function/translate/TranslateFunction.java +++ b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/function/translate/TranslateFunction.java @@ -32,6 +32,9 @@ import org.apache.spark.sql.Dataset; import org.apache.spark.sql.Row; import org.apache.spark.sql.functions; +import org.hl7.fhir.r4.model.BooleanType; +import org.hl7.fhir.r4.model.StringType; +import org.hl7.fhir.r4.model.Type; import org.slf4j.MDC; /** @@ -82,7 +85,7 @@ private Arguments(@Nonnull final List arguments) { */ @SuppressWarnings("unchecked") @Nonnull - private T getValueOr(final int index, @Nonnull final T defaultValue) { + private T getValueOr(final int index, @Nonnull final T defaultValue) { return (index < arguments.size()) ? getValue(index, (Class) defaultValue.getClass()) : defaultValue; @@ -91,15 +94,15 @@ private T getValueOr(final int index, @Nonnull final T defaultValue) { /** * Gets the value of the required literal argument. * - * @param index the 0-based index of the argument. - * @param valueClass the expected Java class of the argument value. - * @param the Java type of the argument value. - * @return the java value of the requested argument. + * @param index the 0-based index of the argument + * @param valueClass the expected Java class of the argument value + * @param the HAPI type of the argument value + * @return the java value of the requested argument */ @Nonnull - public T getValue(final int index, @Nonnull final Class valueClass) { + public T getValue(final int index, @Nonnull final Class valueClass) { return Objects - .requireNonNull(valueClass.cast(((LiteralPath) arguments.get(index)).getJavaValue())); + .requireNonNull(valueClass.cast(((LiteralPath) arguments.get(index)).getValue())); } /** @@ -146,9 +149,11 @@ public FhirPath invoke(@Nonnull final NamedFunctionInput input) { final Arguments arguments = Arguments.of(input); - final String conceptMapUrl = arguments.getValue(0, String.class); - final boolean reverse = arguments.getValueOr(1, DEFAULT_REVERSE); - final String equivalence = arguments.getValueOr(2, DEFAULT_EQUIVALENCE); + final String conceptMapUrl = arguments.getValue(0, StringType.class).asStringValue(); + final boolean reverse = arguments.getValueOr(1, new BooleanType(DEFAULT_REVERSE)) + .booleanValue(); + final String equivalence = arguments.getValueOr(2, new StringType(DEFAULT_EQUIVALENCE)) + .asStringValue(); final Dataset dataset = inputPath.getDataset(); final Dataset translatedDataset = TerminologyFunctions.translate( diff --git a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/literal/BooleanLiteralPath.java b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/literal/BooleanLiteralPath.java index 853b98289a..a3b23cf61b 100644 --- a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/literal/BooleanLiteralPath.java +++ b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/literal/BooleanLiteralPath.java @@ -6,7 +6,7 @@ package au.csiro.pathling.fhirpath.literal; -import static au.csiro.pathling.utilities.Preconditions.check; +import static org.apache.spark.sql.functions.lit; import au.csiro.pathling.fhirpath.Comparable; import au.csiro.pathling.fhirpath.FhirPath; @@ -19,21 +19,19 @@ import org.apache.spark.sql.Dataset; import org.apache.spark.sql.Row; import org.hl7.fhir.r4.model.BooleanType; -import org.hl7.fhir.r4.model.Type; /** * Represents a FHIRPath boolean literal. * * @author John Grimes */ -public class BooleanLiteralPath extends LiteralPath implements Materializable, - Comparable { +public class BooleanLiteralPath extends LiteralPath implements + Materializable, Comparable { @SuppressWarnings("WeakerAccess") protected BooleanLiteralPath(@Nonnull final Dataset dataset, @Nonnull final Column idColumn, - @Nonnull final Type literalValue) { + @Nonnull final BooleanType literalValue) { super(dataset, idColumn, literalValue); - check(literalValue instanceof BooleanType); } /** @@ -55,24 +53,19 @@ public static BooleanLiteralPath fromString(@Nonnull final String fhirPath, @Nonnull @Override public String getExpression() { - return getLiteralValue().asStringValue(); - } - - @Override - public BooleanType getLiteralValue() { - return (BooleanType) literalValue; + return getValue().asStringValue(); } @Nonnull @Override - public Boolean getJavaValue() { - return getLiteralValue().booleanValue(); + public Column buildValueColumn() { + return lit(getValue().booleanValue()); } @Override @Nonnull public Function getComparison(@Nonnull final ComparisonOperation operation) { - return Comparable.buildComparison(this, operation.getSparkFunction()); + return Comparable.buildComparison(this, operation); } @Override diff --git a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/literal/CodingLiteralPath.java b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/literal/CodingLiteralPath.java index 97fac6b574..88d4bd5bef 100644 --- a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/literal/CodingLiteralPath.java +++ b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/literal/CodingLiteralPath.java @@ -6,13 +6,13 @@ package au.csiro.pathling.fhirpath.literal; -import static au.csiro.pathling.utilities.Preconditions.check; import static org.apache.spark.sql.functions.lit; import static org.apache.spark.sql.functions.struct; import au.csiro.pathling.fhirpath.Comparable; import au.csiro.pathling.fhirpath.FhirPath; import au.csiro.pathling.fhirpath.Materializable; +import au.csiro.pathling.fhirpath.comparison.CodingSqlComparator; import au.csiro.pathling.fhirpath.element.CodingPath; import java.util.Optional; import java.util.function.Function; @@ -22,7 +22,6 @@ import org.apache.spark.sql.Dataset; import org.apache.spark.sql.Row; import org.hl7.fhir.r4.model.Coding; -import org.hl7.fhir.r4.model.Type; /** * Represents a FHIRPath Coding literal. @@ -30,13 +29,17 @@ * @author John Grimes */ @Getter -public class CodingLiteralPath extends LiteralPath implements Materializable, Comparable { +public class CodingLiteralPath extends LiteralPath implements Materializable, + Comparable { - @SuppressWarnings("WeakerAccess") protected CodingLiteralPath(@Nonnull final Dataset dataset, @Nonnull final Column idColumn, - @Nonnull final Type literalValue) { + @Nonnull final Coding literalValue) { super(dataset, idColumn, literalValue); - check(literalValue instanceof Coding); + } + + protected CodingLiteralPath(@Nonnull final Dataset dataset, @Nonnull final Column idColumn, + @Nonnull final Coding literalValue, @Nonnull final String expression) { + super(dataset, idColumn, literalValue, expression); } /** @@ -49,34 +52,23 @@ protected CodingLiteralPath(@Nonnull final Dataset dataset, @Nonnull final * @throws IllegalArgumentException if the literal is malformed */ @Nonnull - public static CodingLiteralPath fromString(@Nonnull final CharSequence fhirPath, + public static CodingLiteralPath fromString(@Nonnull final String fhirPath, @Nonnull final FhirPath context) throws IllegalArgumentException { return new CodingLiteralPath(context.getDataset(), context.getIdColumn(), - CodingLiteral.fromString(fhirPath)); + CodingLiteral.fromString(fhirPath), fhirPath); } @Nonnull @Override public String getExpression() { - return CodingLiteral.toLiteral(getLiteralValue()); - - } + return expression.orElse(CodingLiteral.toLiteral(getValue())); - @Override - public Coding getLiteralValue() { - return (Coding) literalValue; - } - - @Nonnull - @Override - public Coding getJavaValue() { - return getLiteralValue(); } @Nonnull @Override public Column buildValueColumn() { - final Coding value = getJavaValue(); + final Coding value = getValue(); return struct( lit(value.getId()).as("id"), lit(value.getSystem()).as("system"), @@ -92,7 +84,7 @@ public Column buildValueColumn() { @Override @Nonnull public Function getComparison(@Nonnull final ComparisonOperation operation) { - return CodingPath.buildComparison(this, operation); + return CodingSqlComparator.buildComparison(this, operation); } @Override @@ -114,7 +106,7 @@ public boolean canBeCombinedWith(@Nonnull final FhirPath target) { @Nonnull @Override public Column getExtractableColumn() { - return lit(CodingLiteral.toLiteral(getLiteralValue())); + return lit(CodingLiteral.toLiteral(getValue())); } } diff --git a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/literal/DateLiteralPath.java b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/literal/DateLiteralPath.java index 6126befe9f..21fa74f686 100644 --- a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/literal/DateLiteralPath.java +++ b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/literal/DateLiteralPath.java @@ -6,16 +6,20 @@ package au.csiro.pathling.fhirpath.literal; -import static au.csiro.pathling.utilities.Preconditions.check; +import static au.csiro.pathling.fhirpath.Temporal.buildDateArithmeticOperation; import static org.apache.spark.sql.functions.lit; import au.csiro.pathling.fhirpath.Comparable; import au.csiro.pathling.fhirpath.FhirPath; import au.csiro.pathling.fhirpath.Materializable; +import au.csiro.pathling.fhirpath.Numeric.MathOperation; +import au.csiro.pathling.fhirpath.Temporal; +import au.csiro.pathling.fhirpath.comparison.DateTimeSqlComparator; import au.csiro.pathling.fhirpath.element.DatePath; import au.csiro.pathling.fhirpath.element.DateTimePath; +import au.csiro.pathling.sql.dates.date.DateAddDurationFunction; +import au.csiro.pathling.sql.dates.date.DateSubtractDurationFunction; import java.text.ParseException; -import java.util.Date; import java.util.Optional; import java.util.function.Function; import javax.annotation.Nonnull; @@ -23,24 +27,23 @@ import org.apache.spark.sql.Dataset; import org.apache.spark.sql.Row; import org.hl7.fhir.r4.model.DateType; -import org.hl7.fhir.r4.model.Type; /** * Represents a FHIRPath date literal. * * @author John Grimes */ -public class DateLiteralPath extends LiteralPath implements Materializable, Comparable { +public class DateLiteralPath extends LiteralPath implements Materializable, + Comparable, Temporal { - @Nonnull - private Optional format; - - @SuppressWarnings("WeakerAccess") protected DateLiteralPath(@Nonnull final Dataset dataset, @Nonnull final Column idColumn, - @Nonnull final Type literalValue) { + @Nonnull final DateType literalValue) { super(dataset, idColumn, literalValue); - check(literalValue instanceof DateType); - format = Optional.empty(); + } + + protected DateLiteralPath(@Nonnull final Dataset dataset, @Nonnull final Column idColumn, + @Nonnull final DateType literalValue, @Nonnull final String expression) { + super(dataset, idColumn, literalValue, expression); } /** @@ -55,63 +58,26 @@ protected DateLiteralPath(@Nonnull final Dataset dataset, @Nonnull final Co public static DateLiteralPath fromString(@Nonnull final String fhirPath, @Nonnull final FhirPath context) throws ParseException { final String dateString = fhirPath.replaceFirst("^@", ""); - java.util.Date date; - DateLiteralFormat format; - // Try parsing out the date using the three possible formats, from full (most common) down to - // the year only format. - try { - date = DatePath.getFullDateFormat().parse(dateString); - format = DateLiteralFormat.FULL; - } catch (final ParseException e) { - try { - date = DatePath.getYearMonthDateFormat().parse(dateString); - format = DateLiteralFormat.YEAR_MONTH_DATE; - } catch (final ParseException ex) { - date = DatePath.getYearOnlyDateFormat().parse(dateString); - format = DateLiteralFormat.YEAR_ONLY; - } - } - - final DateLiteralPath result = new DateLiteralPath(context.getDataset(), context.getIdColumn(), - new DateType(date)); - result.format = Optional.of(format); - return result; + final DateType dateType = new DateType(dateString); + return new DateLiteralPath(context.getDataset(), context.getIdColumn(), dateType, fhirPath); } @Nonnull @Override public String getExpression() { - if (format.isEmpty() || format.get() == DateLiteralFormat.FULL) { - return "@" + DatePath.getFullDateFormat().format(getLiteralValue().getValue()); - } else if (format.get() == DateLiteralFormat.YEAR_MONTH_DATE) { - return "@" + DatePath.getYearMonthDateFormat().format(getLiteralValue().getValue()); - } else { - return "@" + DatePath.getYearOnlyDateFormat().format(getLiteralValue().getValue()); - } - } - - @Override - public DateType getLiteralValue() { - return (DateType) literalValue; - } - - @Nonnull - @Override - public Date getJavaValue() { - return getLiteralValue().getValue(); + return expression.orElse("@" + getValue().asStringValue()); } @Nonnull @Override public Column buildValueColumn() { - final String date = DatePath.getFullDateFormat().format(getJavaValue()); - return lit(date); + return lit(getValue().asStringValue()); } @Override @Nonnull public Function getComparison(@Nonnull final ComparisonOperation operation) { - return DateTimePath.buildComparison(this, operation.getSparkFunction()); + return DateTimeSqlComparator.buildComparison(this, operation); } @Override @@ -130,8 +96,13 @@ public boolean canBeCombinedWith(@Nonnull final FhirPath target) { return super.canBeCombinedWith(target) || target instanceof DatePath; } - private enum DateLiteralFormat { - FULL, YEAR_MONTH_DATE, YEAR_ONLY + @Nonnull + @Override + public Function getDateArithmeticOperation( + @Nonnull final MathOperation operation, @Nonnull final Dataset dataset, + @Nonnull final String expression) { + return buildDateArithmeticOperation(this, operation, dataset, expression, + DateAddDurationFunction.FUNCTION_NAME, DateSubtractDurationFunction.FUNCTION_NAME); } } diff --git a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/literal/DateTimeLiteralPath.java b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/literal/DateTimeLiteralPath.java index 7636517df0..9109c89504 100644 --- a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/literal/DateTimeLiteralPath.java +++ b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/literal/DateTimeLiteralPath.java @@ -6,15 +6,19 @@ package au.csiro.pathling.fhirpath.literal; -import static au.csiro.pathling.utilities.Preconditions.check; +import static au.csiro.pathling.fhirpath.Temporal.buildDateArithmeticOperation; import static org.apache.spark.sql.functions.lit; import au.csiro.pathling.fhirpath.Comparable; import au.csiro.pathling.fhirpath.FhirPath; import au.csiro.pathling.fhirpath.Materializable; +import au.csiro.pathling.fhirpath.Numeric.MathOperation; +import au.csiro.pathling.fhirpath.Temporal; +import au.csiro.pathling.fhirpath.comparison.DateTimeSqlComparator; import au.csiro.pathling.fhirpath.element.DateTimePath; +import au.csiro.pathling.sql.dates.datetime.DateTimeAddDurationFunction; +import au.csiro.pathling.sql.dates.datetime.DateTimeSubtractDurationFunction; import java.text.ParseException; -import java.util.Date; import java.util.Optional; import java.util.function.Function; import javax.annotation.Nonnull; @@ -24,21 +28,23 @@ import org.hl7.fhir.r4.model.BaseDateTimeType; import org.hl7.fhir.r4.model.DateTimeType; import org.hl7.fhir.r4.model.Enumerations.FHIRDefinedType; -import org.hl7.fhir.r4.model.Type; /** * Represents a FHIRPath date literal. * * @author John Grimes */ -public class DateTimeLiteralPath extends LiteralPath implements Materializable, - Comparable { +public class DateTimeLiteralPath extends LiteralPath implements + Materializable, Comparable, Temporal { - @SuppressWarnings("WeakerAccess") protected DateTimeLiteralPath(@Nonnull final Dataset dataset, @Nonnull final Column idColumn, - @Nonnull final Type literalValue) { + @Nonnull final BaseDateTimeType literalValue) { super(dataset, idColumn, literalValue); - check(literalValue instanceof BaseDateTimeType); + } + + protected DateTimeLiteralPath(@Nonnull final Dataset dataset, @Nonnull final Column idColumn, + @Nonnull final BaseDateTimeType literalValue, @Nonnull final String expression) { + super(dataset, idColumn, literalValue, expression); } /** @@ -50,42 +56,31 @@ protected DateTimeLiteralPath(@Nonnull final Dataset dataset, @Nonnull fina * @return A new instance of {@link LiteralPath} * @throws ParseException if the literal is malformed */ + @Nonnull public static DateTimeLiteralPath fromString(@Nonnull final String fhirPath, @Nonnull final FhirPath context) throws ParseException { final String dateTimeString = fhirPath.replaceFirst("^@", ""); - final java.util.Date date = DateTimePath.getDateFormat().parse(dateTimeString); - final DateTimeType literalValue = new DateTimeType(date); - literalValue.setTimeZone(DateTimePath.getTimeZone()); - return new DateTimeLiteralPath(context.getDataset(), context.getIdColumn(), literalValue); + final DateTimeType dateTimeType = new DateTimeType(dateTimeString); + return new DateTimeLiteralPath(context.getDataset(), context.getIdColumn(), dateTimeType, + fhirPath); } @Nonnull @Override public String getExpression() { - return "@" + DateTimePath.getDateFormat().format(getLiteralValue().getValue()); - } - - @Override - public BaseDateTimeType getLiteralValue() { - return (BaseDateTimeType) literalValue; - } - - @Nonnull - @Override - public Date getJavaValue() { - return getLiteralValue().getValue(); + return expression.orElse("@" + getValue().getValueAsString()); } @Nonnull @Override public Column buildValueColumn() { - return lit(getLiteralValue().asStringValue()); + return lit(getValue().asStringValue()); } @Override @Nonnull public Function getComparison(@Nonnull final ComparisonOperation operation) { - return DateTimePath.buildComparison(this, operation.getSparkFunction()); + return DateTimeSqlComparator.buildComparison(this, operation); } @Override @@ -105,4 +100,13 @@ public boolean canBeCombinedWith(@Nonnull final FhirPath target) { return super.canBeCombinedWith(target) || target instanceof DateTimePath; } + @Nonnull + @Override + public Function getDateArithmeticOperation( + @Nonnull final MathOperation operation, @Nonnull final Dataset dataset, + @Nonnull final String expression) { + return buildDateArithmeticOperation(this, operation, dataset, expression, + DateTimeAddDurationFunction.FUNCTION_NAME, DateTimeSubtractDurationFunction.FUNCTION_NAME); + } + } diff --git a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/literal/DecimalLiteralPath.java b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/literal/DecimalLiteralPath.java index 7849b8b89f..4d7541916b 100644 --- a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/literal/DecimalLiteralPath.java +++ b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/literal/DecimalLiteralPath.java @@ -6,7 +6,7 @@ package au.csiro.pathling.fhirpath.literal; -import static au.csiro.pathling.utilities.Preconditions.check; +import static org.apache.spark.sql.functions.lit; import au.csiro.pathling.errors.InvalidUserInputError; import au.csiro.pathling.fhirpath.Comparable; @@ -25,21 +25,18 @@ import org.apache.spark.sql.Row; import org.hl7.fhir.r4.model.DecimalType; import org.hl7.fhir.r4.model.Enumerations.FHIRDefinedType; -import org.hl7.fhir.r4.model.Type; /** * Represents a FHIRPath decimal literal. * * @author John Grimes */ -public class DecimalLiteralPath extends LiteralPath implements Materializable, - Comparable, Numeric { +public class DecimalLiteralPath extends LiteralPath implements + Materializable, Comparable, Numeric { - @SuppressWarnings("WeakerAccess") protected DecimalLiteralPath(@Nonnull final Dataset dataset, @Nonnull final Column idColumn, - @Nonnull final Type literalValue) { + @Nonnull final DecimalType literalValue) { super(dataset, idColumn, literalValue); - check(literalValue instanceof DecimalType); } /** @@ -73,25 +70,19 @@ public static DecimalLiteralPath fromString(@Nonnull final String fhirPath, @Nonnull @Override public String getExpression() { - return getLiteralValue().getValue().toPlainString(); - } - - @Override - @Nonnull - public DecimalType getLiteralValue() { - return (DecimalType) literalValue; + return getValue().getValue().toPlainString(); } @Nonnull @Override - public BigDecimal getJavaValue() { - return getLiteralValue().getValue(); + public Column buildValueColumn() { + return lit(getValue().getValue()); } @Override @Nonnull public Function getComparison(@Nonnull final ComparisonOperation operation) { - return Comparable.buildComparison(this, operation.getSparkFunction()); + return Comparable.buildComparison(this, operation); } @Override @@ -104,7 +95,25 @@ public boolean isComparableTo(@Nonnull final Class type) { public Function getMathOperation(@Nonnull final MathOperation operation, @Nonnull final String expression, @Nonnull final Dataset dataset) { return DecimalPath - .buildMathOperation(this, operation, expression, dataset, FHIRDefinedType.DECIMAL); + .buildMathOperation(this, operation, expression, dataset); + } + + @Nonnull + @Override + public Column getNumericValueColumn() { + return getValueColumn(); + } + + @Nonnull + @Override + public Column getNumericContextColumn() { + return getNumericValueColumn(); + } + + @Nonnull + @Override + public FHIRDefinedType getFhirType() { + return FHIRDefinedType.DECIMAL; } @Nonnull diff --git a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/literal/IntegerLiteralPath.java b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/literal/IntegerLiteralPath.java index 55c0db84fb..984fffac20 100644 --- a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/literal/IntegerLiteralPath.java +++ b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/literal/IntegerLiteralPath.java @@ -6,7 +6,7 @@ package au.csiro.pathling.fhirpath.literal; -import static au.csiro.pathling.utilities.Preconditions.check; +import static org.apache.spark.sql.functions.lit; import au.csiro.pathling.fhirpath.Comparable; import au.csiro.pathling.fhirpath.FhirPath; @@ -20,24 +20,23 @@ import org.apache.spark.sql.Column; import org.apache.spark.sql.Dataset; import org.apache.spark.sql.Row; +import org.apache.spark.sql.types.DataTypes; import org.hl7.fhir.r4.model.Enumerations.FHIRDefinedType; import org.hl7.fhir.r4.model.IntegerType; import org.hl7.fhir.r4.model.PrimitiveType; -import org.hl7.fhir.r4.model.Type; /** * Represents a FHIRPath integer literal. * * @author John Grimes */ -public class IntegerLiteralPath extends LiteralPath implements Materializable, - Comparable, Numeric { +public class IntegerLiteralPath extends LiteralPath implements + Materializable, Comparable, Numeric { @SuppressWarnings("WeakerAccess") protected IntegerLiteralPath(@Nonnull final Dataset dataset, @Nonnull final Column idColumn, - @Nonnull final Type literalValue) { + @Nonnull final PrimitiveType literalValue) { super(dataset, idColumn, literalValue); - check(literalValue instanceof IntegerType); } /** @@ -59,25 +58,19 @@ public static IntegerLiteralPath fromString(@Nonnull final String fhirPath, @Nonnull @Override public String getExpression() { - return getLiteralValue().getValueAsString(); - } - - @Override - @Nonnull - public IntegerType getLiteralValue() { - return (IntegerType) literalValue; + return getValue().getValueAsString(); } @Nonnull @Override - public Integer getJavaValue() { - return getLiteralValue().getValue(); + public Column buildValueColumn() { + return lit(getValue().getValue()); } @Override @Nonnull public Function getComparison(@Nonnull final ComparisonOperation operation) { - return Comparable.buildComparison(this, operation.getSparkFunction()); + return Comparable.buildComparison(this, operation); } @Override @@ -90,7 +83,25 @@ public boolean isComparableTo(@Nonnull final Class type) { public Function getMathOperation(@Nonnull final MathOperation operation, @Nonnull final String expression, @Nonnull final Dataset dataset) { return IntegerPath - .buildMathOperation(this, operation, expression, dataset, FHIRDefinedType.INTEGER); + .buildMathOperation(this, operation, expression, dataset); + } + + @Nonnull + @Override + public Column getNumericValueColumn() { + return getValueColumn().cast(DataTypes.LongType); + } + + @Nonnull + @Override + public Column getNumericContextColumn() { + return getNumericValueColumn(); + } + + @Nonnull + @Override + public FHIRDefinedType getFhirType() { + return FHIRDefinedType.INTEGER; } @Nonnull diff --git a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/literal/LiteralPath.java b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/literal/LiteralPath.java index 8b709b0aaa..697bf61da9 100644 --- a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/literal/LiteralPath.java +++ b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/literal/LiteralPath.java @@ -7,7 +7,6 @@ package au.csiro.pathling.fhirpath.literal; import static au.csiro.pathling.QueryHelpers.getUnionableColumns; -import static org.apache.spark.sql.functions.lit; import au.csiro.pathling.errors.InvalidUserInputError; import au.csiro.pathling.fhirpath.FhirPath; @@ -16,10 +15,10 @@ import com.google.common.collect.ImmutableMap; import java.lang.reflect.Constructor; import java.lang.reflect.InvocationTargetException; +import java.util.Arrays; import java.util.Map; import java.util.Optional; import javax.annotation.Nonnull; -import javax.annotation.Nullable; import lombok.Getter; import org.apache.spark.sql.Column; import org.apache.spark.sql.Dataset; @@ -32,7 +31,7 @@ * * @author John Grimes */ -public abstract class LiteralPath implements FhirPath { +public abstract class LiteralPath implements FhirPath { // See https://hl7.org/fhir/fhirpath.html#types. private static final Map> FHIR_TYPE_TO_FHIRPATH_TYPE = @@ -89,14 +88,27 @@ public abstract class LiteralPath implements FhirPath { * The HAPI object that represents the value of this literal. */ @Getter - protected Type literalValue; + protected ValueType value; + + @Nonnull + protected final Optional expression; protected LiteralPath(@Nonnull final Dataset dataset, @Nonnull final Column idColumn, - @Nonnull final Type literalValue) { + @Nonnull final ValueType value) { this.idColumn = idColumn; - this.literalValue = literalValue; + this.value = value; this.dataset = dataset; this.valueColumn = buildValueColumn(); + this.expression = Optional.empty(); + } + + protected LiteralPath(@Nonnull final Dataset dataset, @Nonnull final Column idColumn, + @Nonnull final ValueType value, @Nonnull final String expression) { + this.idColumn = idColumn; + this.value = value; + this.dataset = dataset; + this.valueColumn = buildValueColumn(); + this.expression = Optional.of(expression); } /** @@ -113,12 +125,19 @@ public static String expressionFor(@Nonnull final Dataset dataset, final Class literalPathClass = FHIR_TYPE_TO_FHIRPATH_TYPE .get(FHIRDefinedType.fromCode(literalValue.fhirType())); try { - final Constructor constructor = literalPathClass - .getDeclaredConstructor(Dataset.class, Column.class, Type.class); + @SuppressWarnings("unchecked") + final Constructor constructor = (Constructor) Arrays.stream( + literalPathClass.getDeclaredConstructors()) + .filter(c -> c.getParameterCount() == 3) + .filter(c -> c.getParameterTypes()[0] == Dataset.class) + .filter(c -> c.getParameterTypes()[1] == Column.class) + .filter(c -> Type.class.isAssignableFrom(c.getParameterTypes()[2])) + .findFirst() + .orElseThrow(() -> new AssertionError( + "No suitable constructor found for " + literalPathClass)); final LiteralPath literalPath = constructor.newInstance(dataset, idColumn, literalValue); return literalPath.getExpression(); - } catch (final NoSuchMethodException | InstantiationException | IllegalAccessException | - InvocationTargetException e) { + } catch (final InstantiationException | IllegalAccessException | InvocationTargetException e) { throw new RuntimeException("Problem building a LiteralPath class", e); } } @@ -154,21 +173,11 @@ public Column getExtractableColumn() { return getValueColumn(); } - /** - * Returns the Java object that represents the value of this literal. - * - * @return An Object - */ - @Nullable - public abstract Object getJavaValue(); - /** * @return A column representing the value for this literal. */ @Nonnull - public Column buildValueColumn() { - return lit(getJavaValue()); - } + public abstract Column buildValueColumn(); /** * @param fhirPathClass a subclass of LiteralPath diff --git a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/literal/NullLiteralPath.java b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/literal/NullLiteralPath.java index 1dbcac5c64..419aecbb4e 100644 --- a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/literal/NullLiteralPath.java +++ b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/literal/NullLiteralPath.java @@ -12,7 +12,6 @@ import au.csiro.pathling.fhirpath.FhirPath; import java.util.function.Function; import javax.annotation.Nonnull; -import javax.annotation.Nullable; import org.apache.spark.sql.Column; import org.apache.spark.sql.Dataset; import org.apache.spark.sql.Row; @@ -23,11 +22,10 @@ * * @author John Grimes */ -public class NullLiteralPath extends LiteralPath implements Comparable { +public class NullLiteralPath extends LiteralPath implements Comparable { private static final String EXPRESSION = "{}"; - @SuppressWarnings("WeakerAccess") protected NullLiteralPath(@Nonnull final Dataset dataset, @Nonnull final Column idColumn) { // We put a dummy String value in here as a placeholder so that we can satisfy the nullability // constraints within LiteralValue. It is never accessed. @@ -54,10 +52,10 @@ public String getExpression() { return EXPRESSION; } - @Nullable + @Nonnull @Override - public Object getJavaValue() { - return null; + public Column buildValueColumn() { + return lit(null); } @Override diff --git a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/literal/QuantityLiteralPath.java b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/literal/QuantityLiteralPath.java index 28d9eb33dd..c0f831df9a 100644 --- a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/literal/QuantityLiteralPath.java +++ b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/literal/QuantityLiteralPath.java @@ -6,19 +6,32 @@ package au.csiro.pathling.fhirpath.literal; -import static au.csiro.pathling.utilities.Preconditions.check; +import static org.apache.spark.sql.functions.struct; +import au.csiro.pathling.encoders.terminology.ucum.Ucum; +import au.csiro.pathling.errors.InvalidUserInputError; +import au.csiro.pathling.fhirpath.Comparable; import au.csiro.pathling.fhirpath.FhirPath; +import au.csiro.pathling.fhirpath.NonLiteralPath; +import au.csiro.pathling.fhirpath.Numeric; +import au.csiro.pathling.fhirpath.CalendarDurationUtils; +import au.csiro.pathling.fhirpath.comparison.QuantitySqlComparator; +import au.csiro.pathling.fhirpath.element.QuantityPath; +import au.csiro.pathling.fhirpath.encoding.QuantityEncoding; import java.math.BigDecimal; +import java.util.Optional; +import java.util.function.Function; import java.util.regex.Matcher; import java.util.regex.Pattern; import javax.annotation.Nonnull; +import javax.annotation.Nullable; import lombok.Getter; import org.apache.spark.sql.Column; import org.apache.spark.sql.Dataset; import org.apache.spark.sql.Row; +import org.fhir.ucum.UcumService; +import org.hl7.fhir.r4.model.Enumerations.FHIRDefinedType; import org.hl7.fhir.r4.model.Quantity; -import org.hl7.fhir.r4.model.Type; /** * Represents a FHIRPath Quantity literal. @@ -26,72 +39,143 @@ * @author John Grimes */ @Getter -public class QuantityLiteralPath extends LiteralPath { +public class QuantityLiteralPath extends LiteralPath implements Comparable, Numeric { - private static final Pattern PATTERN = Pattern.compile("([0-9.]+) ('[^']+')"); + private static final Pattern UCUM_PATTERN = Pattern.compile("([0-9.]+) ('[^']+')"); - @SuppressWarnings("WeakerAccess") protected QuantityLiteralPath(@Nonnull final Dataset dataset, @Nonnull final Column idColumn, - @Nonnull final Type literalValue) { + @Nonnull final Quantity literalValue) { super(dataset, idColumn, literalValue); - check(literalValue instanceof Quantity); + } + + protected QuantityLiteralPath(@Nonnull final Dataset dataset, @Nonnull final Column idColumn, + @Nonnull final Quantity literalValue, @Nonnull final String expression) { + super(dataset, idColumn, literalValue, expression); } /** * Returns a new instance, parsed from a FHIRPath literal. * - * @param fhirPath The FHIRPath representation of the literal - * @param context An input context that can be used to build a {@link Dataset} to represent the + * @param fhirPath the FHIRPath representation of the literal + * @param context an input context that can be used to build a {@link Dataset} to represent the * literal + * @param ucumService a UCUM service for validating the unit within the literal * @return A new instance of {@link LiteralPath} * @throws IllegalArgumentException if the literal is malformed */ @Nonnull - public static QuantityLiteralPath fromString(@Nonnull final String fhirPath, - @Nonnull final FhirPath context) throws IllegalArgumentException { - final Matcher matcher = PATTERN.matcher(fhirPath); + public static QuantityLiteralPath fromUcumString(@Nonnull final String fhirPath, + @Nonnull final FhirPath context, @Nonnull final UcumService ucumService) { + final Matcher matcher = UCUM_PATTERN.matcher(fhirPath); if (!matcher.matches()) { - throw new IllegalArgumentException("Quantity literal has invalid format: " + fhirPath); + throw new IllegalArgumentException("UCUM Quantity literal has invalid format: " + fhirPath); } - + final String fullPath = matcher.group(0); + final String value = matcher.group(1); final String rawUnit = matcher.group(2); - final String unit = StringLiteralPath.fromString(rawUnit, context).getLiteralValue() + final String unit = StringLiteralPath.fromString(rawUnit, context).getValue() .getValueAsString(); - final Quantity quantity = new Quantity(); - quantity.setUnit(unit); + @Nullable final String validationResult = ucumService.validate(unit); + if (validationResult != null) { + throw new InvalidUserInputError( + "Invalid UCUM unit provided within Quantity literal (" + fullPath + "): " + + validationResult); + } + + final BigDecimal decimalValue = getQuantityValue(value, context); + @Nullable final String display = ucumService.getCommonDisplay(unit); + + return buildLiteralPath(decimalValue, unit, Optional.ofNullable(display), context, fhirPath); + } + + /** + * Returns a new instance, parsed from a FHIRPath literal representing a calendar duration. + * + * @param fhirPath the FHIRPath representation of the literal + * @param context an input context that can be used to build a {@link Dataset} to represent the + * literal A new instance of {@link QuantityLiteralPath} + * @see Time-valued quantities + */ + @Nonnull + public static QuantityLiteralPath fromCalendarDurationString(@Nonnull final String fhirPath, + @Nonnull final FhirPath context) { + + return new QuantityLiteralPath(context.getDataset(), context.getIdColumn(), + CalendarDurationUtils.parseCalendarDuration(fhirPath), fhirPath); + } + + private static BigDecimal getQuantityValue(final String value, final @Nonnull FhirPath context) { + final BigDecimal decimalValue; try { - final long value = IntegerLiteralPath.fromString(fhirPath, context) - .getLiteralValue().getValue(); - quantity.setValue(value); + decimalValue = DecimalLiteralPath.fromString(value, context).getValue().getValue(); } catch (final NumberFormatException e) { - try { - final BigDecimal value = DecimalLiteralPath.fromString(fhirPath, context) - .getLiteralValue().getValue(); - quantity.setValue(value); - } catch (final NumberFormatException ex) { - throw new IllegalArgumentException("Quantity literal has invalid format: " + fhirPath); - } + throw new IllegalArgumentException("Quantity literal has invalid value: " + value); } + return decimalValue; + } + + @Nonnull + private static QuantityLiteralPath buildLiteralPath(@Nonnull final BigDecimal decimalValue, + @Nonnull final String unit, @Nonnull final Optional display, + final @Nonnull FhirPath context, @Nonnull final String fhirPath) { + final Quantity quantity = new Quantity(); + quantity.setValue(decimalValue); + quantity.setSystem(Ucum.SYSTEM_URI); + quantity.setCode(unit); + display.ifPresent(quantity::setUnit); - return new QuantityLiteralPath(context.getDataset(), context.getIdColumn(), quantity); + return new QuantityLiteralPath(context.getDataset(), context.getIdColumn(), quantity, fhirPath); } @Nonnull @Override public String getExpression() { - return getLiteralValue().getValue().toPlainString() + " '" + getLiteralValue().getUnit() + "'"; + return expression.orElse( + getValue().getValue().toPlainString() + " '" + getValue().getUnit() + "'"); } + @Nonnull + @Override + public Column buildValueColumn() { + return QuantityEncoding.encodeLiteral(getValue()); + } + + @Nonnull + @Override + public Function getComparison(@Nonnull final ComparisonOperation operation) { + return QuantitySqlComparator.buildComparison(this, operation); + } + + @Override + public boolean isComparableTo(@Nonnull final Class type) { + return QuantityPath.COMPARABLE_TYPES.contains(type); + } + + @Nonnull + @Override + public Column getNumericValueColumn() { + return getValueColumn().getField(QuantityEncoding.CANONICALIZED_VALUE_COLUMN); + } + + @Nonnull + @Override + public Column getNumericContextColumn() { + return getValueColumn(); + } + + @Nonnull @Override - public Quantity getLiteralValue() { - return (Quantity) literalValue; + public FHIRDefinedType getFhirType() { + return FHIRDefinedType.QUANTITY; } @Nonnull @Override - public Quantity getJavaValue() { - return getLiteralValue(); + public Function getMathOperation(@Nonnull final MathOperation operation, + @Nonnull final String expression, @Nonnull final Dataset dataset) { + return QuantityPath.buildMathOperation(this, operation, expression, dataset, + Optional.empty()); } } diff --git a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/literal/StringLiteralPath.java b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/literal/StringLiteralPath.java index 4131d44c29..6dbbae6d12 100644 --- a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/literal/StringLiteralPath.java +++ b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/literal/StringLiteralPath.java @@ -7,9 +7,8 @@ package au.csiro.pathling.fhirpath.literal; import static au.csiro.pathling.fhirpath.literal.StringLiteral.escapeFhirPathString; -import static au.csiro.pathling.fhirpath.literal.StringLiteral.unescapeFhirPathString; -import static au.csiro.pathling.utilities.Preconditions.check; import static au.csiro.pathling.utilities.Strings.unSingleQuote; +import static org.apache.spark.sql.functions.lit; import au.csiro.pathling.fhirpath.Comparable; import au.csiro.pathling.fhirpath.FhirPath; @@ -25,7 +24,6 @@ import org.hl7.fhir.r4.model.Enumerations.FHIRDefinedType; import org.hl7.fhir.r4.model.PrimitiveType; import org.hl7.fhir.r4.model.StringType; -import org.hl7.fhir.r4.model.Type; /** * Represents a FHIRPath string literal. @@ -33,13 +31,12 @@ * @author John Grimes */ @Getter -public class StringLiteralPath extends LiteralPath implements Materializable, - Comparable { +public class StringLiteralPath extends LiteralPath implements + Materializable, Comparable { protected StringLiteralPath(@Nonnull final Dataset dataset, @Nonnull final Column idColumn, - @Nonnull final Type literalValue) { + @Nonnull final PrimitiveType literalValue) { super(dataset, idColumn, literalValue); - check(literalValue instanceof PrimitiveType); } /** @@ -65,25 +62,38 @@ public static StringLiteralPath fromString(@Nonnull final String fhirPath, @Nonnull @Override public String getExpression() { - return "'" + escapeFhirPathString(getLiteralValue().getValueAsString()) + "'"; + return "'" + escapeFhirPathString(getValue().getValueAsString()) + "'"; } @Nonnull @Override - public PrimitiveType getLiteralValue() { - return (PrimitiveType) literalValue; + public Column buildValueColumn() { + return lit(getValue().getValueAsString()); } + /** + * This method implements the rules for dealing with strings in the FHIRPath specification. + * + * @param value the string to be unescaped + * @return the unescaped result + * @see String + */ @Nonnull - @Override - public String getJavaValue() { - return getLiteralValue().getValueAsString(); + public static String unescapeFhirPathString(@Nonnull String value) { + value = value.replaceAll("\\\\/", "/"); + value = value.replaceAll("\\\\f", "\u000C"); + value = value.replaceAll("\\\\n", "\n"); + value = value.replaceAll("\\\\r", "\r"); + value = value.replaceAll("\\\\t", "\u0009"); + value = value.replaceAll("\\\\`", "`"); + value = value.replaceAll("\\\\'", "'"); + return value.replaceAll("\\\\\\\\", "\\\\"); } @Override @Nonnull public Function getComparison(@Nonnull final ComparisonOperation operation) { - return Comparable.buildComparison(this, operation.getSparkFunction()); + return Comparable.buildComparison(this, operation); } @Override diff --git a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/literal/TimeLiteralPath.java b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/literal/TimeLiteralPath.java index 39f11651f9..2f6373c699 100644 --- a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/literal/TimeLiteralPath.java +++ b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/literal/TimeLiteralPath.java @@ -6,7 +6,7 @@ package au.csiro.pathling.fhirpath.literal; -import static au.csiro.pathling.utilities.Preconditions.check; +import static org.apache.spark.sql.functions.lit; import au.csiro.pathling.fhirpath.Comparable; import au.csiro.pathling.fhirpath.FhirPath; @@ -19,20 +19,23 @@ import org.apache.spark.sql.Dataset; import org.apache.spark.sql.Row; import org.hl7.fhir.r4.model.TimeType; -import org.hl7.fhir.r4.model.Type; /** * Represents a FHIRPath time literal. * * @author John Grimes */ -public class TimeLiteralPath extends LiteralPath implements Materializable, Comparable { +public class TimeLiteralPath extends LiteralPath implements Materializable, + Comparable { - @SuppressWarnings("WeakerAccess") protected TimeLiteralPath(@Nonnull final Dataset dataset, @Nonnull final Column idColumn, - @Nonnull final Type literalValue) { + @Nonnull final TimeType literalValue) { super(dataset, idColumn, literalValue); - check(literalValue instanceof TimeType); + } + + protected TimeLiteralPath(@Nonnull final Dataset dataset, @Nonnull final Column idColumn, + @Nonnull final TimeType literalValue, @Nonnull final String expression) { + super(dataset, idColumn, literalValue, expression); } /** @@ -48,30 +51,25 @@ public static TimeLiteralPath fromString(@Nonnull final String fhirPath, @Nonnull final FhirPath context) { final String timeString = fhirPath.replaceFirst("^@T", ""); return new TimeLiteralPath(context.getDataset(), context.getIdColumn(), - new TimeType(timeString)); + new TimeType(timeString), fhirPath); } @Nonnull @Override public String getExpression() { - return "@T" + getLiteralValue().getValue(); - } - - @Override - public TimeType getLiteralValue() { - return (TimeType) literalValue; + return expression.orElse("@T" + getValue().getValue()); } @Nonnull @Override - public String getJavaValue() { - return getLiteralValue().getValue(); + public Column buildValueColumn() { + return lit(getValue().asStringValue()); } @Override @Nonnull public Function getComparison(@Nonnull final ComparisonOperation operation) { - return Comparable.buildComparison(this, operation.getSparkFunction()); + return Comparable.buildComparison(this, operation); } @Override diff --git a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/operator/DateArithmeticOperator.java b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/operator/DateArithmeticOperator.java new file mode 100644 index 0000000000..236fc372d3 --- /dev/null +++ b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/operator/DateArithmeticOperator.java @@ -0,0 +1,68 @@ +/* + * 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.fhirpath.operator; + +import static au.csiro.pathling.QueryHelpers.join; +import static au.csiro.pathling.fhirpath.operator.Operator.buildExpression; +import static au.csiro.pathling.utilities.Preconditions.checkUserInput; + +import au.csiro.pathling.QueryHelpers.JoinType; +import au.csiro.pathling.fhirpath.CalendarDurationUtils; +import au.csiro.pathling.fhirpath.FhirPath; +import au.csiro.pathling.fhirpath.Numeric.MathOperation; +import au.csiro.pathling.fhirpath.Temporal; +import au.csiro.pathling.fhirpath.literal.QuantityLiteralPath; +import javax.annotation.Nonnull; +import org.apache.spark.sql.Dataset; +import org.apache.spark.sql.Row; + +/** + * Provides the functionality of the family of math operators within FHIRPath, i.e. +, -, *, / and + * mod. + * + * @author John Grimes + * @see Math + */ +public class DateArithmeticOperator implements Operator { + + @Nonnull + private final MathOperation type; + + /** + * @param type The type of math operation + */ + public DateArithmeticOperator(@Nonnull final MathOperation type) { + this.type = type; + } + + @Nonnull + @Override + public FhirPath invoke(@Nonnull final OperatorInput input) { + final FhirPath left = input.getLeft(); + final FhirPath right = input.getRight(); + checkUserInput(left instanceof Temporal, + type + " operator does not support left operand: " + left.getExpression()); + + checkUserInput(right instanceof QuantityLiteralPath, + type + " operator does not support right operand: " + right.getExpression()); + final QuantityLiteralPath calendarDuration = (QuantityLiteralPath) right; + checkUserInput(CalendarDurationUtils.isCalendarDuration(calendarDuration.getValue()), + "Right operand of " + type + " operator must be a calendar duration"); + checkUserInput(left.isSingular(), + "Left operand to " + type + " operator must be singular: " + left.getExpression()); + checkUserInput(right.isSingular(), + "Right operand to " + type + " operator must be singular: " + right.getExpression()); + + final Temporal temporal = (Temporal) left; + final String expression = buildExpression(input, type.toString()); + final Dataset dataset = join(input.getContext(), left, right, JoinType.LEFT_OUTER); + + return temporal.getDateArithmeticOperation(type, dataset, expression) + .apply(calendarDuration); + } + +} diff --git a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/operator/MathOperator.java b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/operator/MathOperator.java index 4a00ef2dff..2e3891354b 100644 --- a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/operator/MathOperator.java +++ b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/operator/MathOperator.java @@ -11,9 +11,12 @@ import static au.csiro.pathling.utilities.Preconditions.checkUserInput; import au.csiro.pathling.QueryHelpers.JoinType; +import au.csiro.pathling.fhirpath.Comparable; import au.csiro.pathling.fhirpath.FhirPath; import au.csiro.pathling.fhirpath.Numeric; import au.csiro.pathling.fhirpath.Numeric.MathOperation; +import au.csiro.pathling.fhirpath.Temporal; +import au.csiro.pathling.fhirpath.literal.QuantityLiteralPath; import javax.annotation.Nonnull; import org.apache.spark.sql.Dataset; import org.apache.spark.sql.Row; @@ -42,6 +45,12 @@ public MathOperator(@Nonnull final MathOperation type) { public FhirPath invoke(@Nonnull final OperatorInput input) { final FhirPath left = input.getLeft(); final FhirPath right = input.getRight(); + + // Check whether this needs to be delegated off to the DateArithmeticOperator. + if (left instanceof Temporal && right instanceof QuantityLiteralPath) { + return new DateArithmeticOperator(type).invoke(input); + } + checkUserInput(left instanceof Numeric, type + " operator does not support left operand: " + left.getExpression()); checkUserInput(right instanceof Numeric, @@ -50,6 +59,14 @@ public FhirPath invoke(@Nonnull final OperatorInput input) { "Left operand to " + type + " operator must be singular: " + left.getExpression()); checkUserInput(right.isSingular(), "Right operand to " + type + " operator must be singular: " + right.getExpression()); + checkUserInput(left instanceof Comparable && right instanceof Comparable, + "Left and right operands are not comparable: " + left.getExpression() + " " + + type + " " + right.getExpression()); + final Comparable comparableLeft = (Comparable) left; + final Comparable comparableRight = (Comparable) right; + checkUserInput(comparableLeft.isComparableTo(comparableRight.getClass()), + "Left and right operands are not comparable: " + left.getExpression() + " " + + type + " " + right.getExpression()); final String expression = buildExpression(input, type.toString()); final Dataset dataset = join(input.getContext(), left, right, JoinType.LEFT_OUTER); diff --git a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/parser/LiteralTermVisitor.java b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/parser/LiteralTermVisitor.java index 3a81f93029..e46a3aa418 100644 --- a/fhir-server/src/main/java/au/csiro/pathling/fhirpath/parser/LiteralTermVisitor.java +++ b/fhir-server/src/main/java/au/csiro/pathling/fhirpath/parser/LiteralTermVisitor.java @@ -8,6 +8,7 @@ import static au.csiro.pathling.utilities.Preconditions.checkNotNull; +import au.csiro.pathling.encoders.terminology.ucum.Ucum; import au.csiro.pathling.errors.InvalidUserInputError; import au.csiro.pathling.fhirpath.FhirPath; import au.csiro.pathling.fhirpath.literal.BooleanLiteralPath; @@ -17,6 +18,7 @@ import au.csiro.pathling.fhirpath.literal.DecimalLiteralPath; import au.csiro.pathling.fhirpath.literal.IntegerLiteralPath; import au.csiro.pathling.fhirpath.literal.NullLiteralPath; +import au.csiro.pathling.fhirpath.literal.QuantityLiteralPath; import au.csiro.pathling.fhirpath.literal.StringLiteralPath; import au.csiro.pathling.fhirpath.literal.TimeLiteralPath; import au.csiro.pathling.fhirpath.parser.generated.FhirPathBaseVisitor; @@ -32,6 +34,8 @@ import java.text.ParseException; import javax.annotation.Nonnull; import javax.annotation.Nullable; +import org.antlr.v4.runtime.tree.TerminalNode; +import org.fhir.ucum.UcumException; /** * This class deals with terms that are literal expressions. @@ -142,7 +146,27 @@ public FhirPath visitNullLiteral(@Nullable final NullLiteralContext ctx) { @Override @Nonnull public FhirPath visitQuantityLiteral(@Nullable final QuantityLiteralContext ctx) { - throw new InvalidUserInputError("Quantity literals are not supported"); + checkNotNull(ctx); + @Nullable final String number = ctx.quantity().NUMBER().getText(); + checkNotNull(number); + + final FhirPath resultContext = this.context.getThisContext().orElse(context.getInputContext()); + @Nullable final TerminalNode ucumUnit = ctx.quantity().unit().STRING(); + + if (ucumUnit == null) { + // Create a calendar duration literal. + final String fhirPath = String.format("%s %s", number, ctx.quantity().unit().getText()); + return QuantityLiteralPath.fromCalendarDurationString(fhirPath, resultContext); + } else { + // Create a UCUM Quantity literal. + final String fhirPath = String.format("%s %s", number, ucumUnit.getText()); + try { + return QuantityLiteralPath.fromUcumString(fhirPath, resultContext, + Ucum.service()); + } catch (final UcumException e) { + throw new RuntimeException(e); + } + } } } diff --git a/fhir-server/src/main/java/au/csiro/pathling/spark/Spark.java b/fhir-server/src/main/java/au/csiro/pathling/spark/Spark.java index 8e092e1905..83d89a05b5 100644 --- a/fhir-server/src/main/java/au/csiro/pathling/spark/Spark.java +++ b/fhir-server/src/main/java/au/csiro/pathling/spark/Spark.java @@ -6,18 +6,20 @@ package au.csiro.pathling.spark; -import au.csiro.pathling.config.Configuration; -import au.csiro.pathling.config.StorageConfiguration.Aws; import au.csiro.pathling.async.SparkListener; -import au.csiro.pathling.sql.CodingToLiteral; -import au.csiro.pathling.sql.PathlingStrategy; +import au.csiro.pathling.config.Configuration; +import au.csiro.pathling.sql.SqlStrategy; +import au.csiro.pathling.sql.udf.SqlFunction1; +import au.csiro.pathling.sql.udf.SqlFunction2; +import au.csiro.pathling.sql.udf.SqlFunction3; import java.util.Arrays; +import java.util.List; import java.util.Objects; import java.util.Optional; +import java.util.function.Consumer; import javax.annotation.Nonnull; import lombok.extern.slf4j.Slf4j; import org.apache.spark.sql.SparkSession; -import org.apache.spark.sql.types.DataTypes; import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Profile; @@ -43,6 +45,9 @@ public class Spark { * creation * @param environment Spring {@link Environment} from which to harvest Spark configuration * @param sparkListener a {@link SparkListener} that is used to monitor progress of jobs + * @param sqlFunction1 a list of {@link SqlFunction1} that should be registered + * @param sqlFunction2 a list of {@link SqlFunction2} that should be registered + * @param sqlFunction3 a list of {@link SqlFunction3} that should be registered * @return A shiny new {@link SparkSession} */ @Bean(destroyMethod = "stop") @@ -50,68 +55,54 @@ public class Spark { @Nonnull public static SparkSession build(@Nonnull final Configuration configuration, @Nonnull final Environment environment, - @Nonnull final Optional sparkListener) { + @Nonnull final Optional sparkListener, + @Nonnull final List> sqlFunction1, + @Nonnull final List> sqlFunction2, + @Nonnull final List> sqlFunction3) { log.debug("Creating Spark session"); - resolveSparkConfiguration(environment); + + // Pass through Spark configuration. + resolveThirdPartyConfiguration(environment, List.of("spark."), + property -> System.setProperty(property, + Objects.requireNonNull(environment.getProperty(property)))); final SparkSession spark = SparkSession.builder() .appName(configuration.getSpark().getAppName()) .getOrCreate(); sparkListener.ifPresent(l -> spark.sparkContext().addSparkListener(l)); - // Configure user defined functions. - PathlingStrategy.setup(spark); - spark.udf() - .register(CodingToLiteral.FUNCTION_NAME, new CodingToLiteral(), DataTypes.StringType); - - // Configure AWS driver and credentials. - configureAwsDriver(configuration, spark); - - return spark; - } - - private static void configureAwsDriver(@Nonnull final Configuration configuration, - @Nonnull final SparkSession spark) { - final Aws awsConfig = configuration.getStorage().getAws(); - final org.apache.hadoop.conf.Configuration hadoopConfig = spark.sparkContext() - .hadoopConfiguration(); - - // We need to use the anonymous credentials provider if we are not using AWS credentials. - if (awsConfig.isAnonymousAccess()) { - hadoopConfig.set("fs.s3a.aws.credentials.provider", - "org.apache.hadoop.fs.s3a.AnonymousAWSCredentialsProvider"); + // Configure user defined strategy and functions. + SqlStrategy.setup(spark); + for (final SqlFunction1 function : sqlFunction1) { + spark.udf().register(function.getName(), function, function.getReturnType()); + } + for (final SqlFunction2 function : sqlFunction2) { + spark.udf().register(function.getName(), function, function.getReturnType()); + } + for (final SqlFunction3 function : sqlFunction3) { + spark.udf().register(function.getName(), function, function.getReturnType()); } - // Set credentials if provided. - awsConfig.getAccessKeyId() - .ifPresent(accessKeyId -> hadoopConfig.set("fs.s3a.access.key", accessKeyId)); - awsConfig.getSecretAccessKey() - .ifPresent(secretAccessKey -> hadoopConfig.set("fs.s3a.secret.key", secretAccessKey)); - hadoopConfig.set("fs.s3a.connection.maximum", "100"); - hadoopConfig.set("fs.s3a.committer.magic.enabled", "true"); - hadoopConfig.set("fs.s3a.committer.name", "magic"); + // Pass through Hadoop AWS configuration. + resolveThirdPartyConfiguration(environment, List.of("fs.s3a."), + property -> spark.sparkContext().hadoopConfiguration().set(property, + Objects.requireNonNull(environment.getProperty(property)))); - // Assume role if configured. - awsConfig.getAssumedRole() - .ifPresent(assumedRole -> { - hadoopConfig.set("fs.s3a.aws.credentials.provider", - "org.apache.hadoop.fs.s3a.auth.AssumedRoleCredentialProvider"); - hadoopConfig.set("fs.s3a.assumed.role.arn", assumedRole); - }); + return spark; } - private static void resolveSparkConfiguration(@Nonnull final PropertyResolver resolver) { - // This goes through the properties within the Spring configuration and copies the Spark - // configuration into Java system properties, which Spark will then pick up. + private static void resolveThirdPartyConfiguration(@Nonnull final PropertyResolver resolver, + @Nonnull final List prefixes, @Nonnull final Consumer setter) { + // This goes through the properties within the Spring configuration and invokes the provided + // setter function for each property that matches one of the supplied prefixes. final MutablePropertySources propertySources = ((AbstractEnvironment) resolver) .getPropertySources(); propertySources.stream() .filter(propertySource -> propertySource instanceof EnumerablePropertySource) .flatMap(propertySource -> Arrays .stream(((EnumerablePropertySource) propertySource).getPropertyNames())) - .filter(property -> property.startsWith("spark.")) - .forEach(property -> System.setProperty(property, - Objects.requireNonNull(resolver.getProperty(property)))); + .filter(property -> prefixes.stream().anyMatch(property::startsWith)) + .forEach(setter); } } diff --git a/encoders/src/main/java/au/csiro/pathling/sql/PathlingFunctions.java b/fhir-server/src/main/java/au/csiro/pathling/sql/SqlExpressions.java similarity index 51% rename from encoders/src/main/java/au/csiro/pathling/sql/PathlingFunctions.java rename to fhir-server/src/main/java/au/csiro/pathling/sql/SqlExpressions.java index 4b7ac4f0af..1ea616f2a0 100644 --- a/encoders/src/main/java/au/csiro/pathling/sql/PathlingFunctions.java +++ b/fhir-server/src/main/java/au/csiro/pathling/sql/SqlExpressions.java @@ -1,14 +1,7 @@ /* - * 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. - * + * 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.sql; @@ -19,7 +12,7 @@ /** * Pathling specific SQL functions. */ -public interface PathlingFunctions { +public interface SqlExpressions { /** * A function that removes all fields starting with '_' (underscore) from struct values. Other diff --git a/fhir-server/src/main/java/au/csiro/pathling/sql/dates/TemporalArithmeticFunction.java b/fhir-server/src/main/java/au/csiro/pathling/sql/dates/TemporalArithmeticFunction.java new file mode 100644 index 0000000000..276405297a --- /dev/null +++ b/fhir-server/src/main/java/au/csiro/pathling/sql/dates/TemporalArithmeticFunction.java @@ -0,0 +1,82 @@ +/* + * 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.sql.dates; + +import au.csiro.pathling.fhirpath.CalendarDurationUtils; +import au.csiro.pathling.fhirpath.encoding.QuantityEncoding; +import au.csiro.pathling.sql.udf.SqlFunction2; +import java.math.RoundingMode; +import java.util.function.BiFunction; +import java.util.function.Function; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import org.apache.spark.sql.Row; +import org.apache.spark.sql.types.DataType; +import org.apache.spark.sql.types.DataTypes; +import org.hl7.fhir.r4.model.BaseDateTimeType; +import org.hl7.fhir.r4.model.Quantity; + +/** + * Base class for functions that perform arithmetic on temporal values. + * + * @author John Grimes + */ +public abstract class TemporalArithmeticFunction implements + SqlFunction2 { + + private static final long serialVersionUID = -5016153440496309996L; + + @Nonnull + protected T performAddition(@Nonnull final T temporal, @Nonnull final Quantity calendarDuration) { + return performArithmetic(temporal, calendarDuration, false); + } + + @Nonnull + protected T performSubtraction(@Nonnull final T temporal, + @Nonnull final Quantity calendarDuration) { + return performArithmetic(temporal, calendarDuration, true); + } + + @Nonnull + private T performArithmetic(final @Nonnull T temporal, final @Nonnull Quantity calendarDuration, + final boolean subtract) { + final int amountToAdd = calendarDuration.getValue().setScale(0, RoundingMode.HALF_UP) + .intValue(); + final int temporalUnit = CalendarDurationUtils.getTemporalUnit(calendarDuration); + + @SuppressWarnings("unchecked") final T result = (T) temporal.copy(); + result.add(temporalUnit, subtract + ? -amountToAdd + : amountToAdd); + return result; + } + + protected abstract Function parseEncodedValue(); + + protected abstract BiFunction getOperationFunction(); + + protected abstract Function encodeResult(); + + @Override + public DataType getReturnType() { + return DataTypes.StringType; + } + + @Nullable + @Override + public String call(@Nullable final String temporalValue, @Nullable final Row calendarDurationRow) + throws Exception { + if (temporalValue == null || calendarDurationRow == null) { + return null; + } + final T temporal = parseEncodedValue().apply(temporalValue); + final Quantity calendarDuration = QuantityEncoding.decode(calendarDurationRow); + final T result = getOperationFunction().apply(temporal, calendarDuration); + return encodeResult().apply(result); + } + +} diff --git a/fhir-server/src/main/java/au/csiro/pathling/sql/dates/TemporalComparisonFunction.java b/fhir-server/src/main/java/au/csiro/pathling/sql/dates/TemporalComparisonFunction.java new file mode 100644 index 0000000000..f1c292ce95 --- /dev/null +++ b/fhir-server/src/main/java/au/csiro/pathling/sql/dates/TemporalComparisonFunction.java @@ -0,0 +1,46 @@ +/* + * 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.sql.dates; + +import au.csiro.pathling.sql.udf.SqlFunction2; +import java.util.function.BiFunction; +import java.util.function.Function; +import javax.annotation.Nullable; +import org.apache.spark.sql.types.DataType; +import org.apache.spark.sql.types.DataTypes; + +/** + * Base class for functions that compare temporal values. + * + * @author John Grimes + */ +public abstract class TemporalComparisonFunction implements + SqlFunction2 { + + private static final long serialVersionUID = 492467651418666881L; + + protected abstract Function parseEncodedValue(); + + protected abstract BiFunction getOperationFunction(); + + @Override + public DataType getReturnType() { + return DataTypes.BooleanType; + } + + @Nullable + @Override + public Boolean call(@Nullable final String left, @Nullable final String right) throws Exception { + if (left == null || right == null) { + return null; + } + final IntermediateType parsedLeft = parseEncodedValue().apply(left); + final IntermediateType parsedRight = parseEncodedValue().apply(right); + return getOperationFunction().apply(parsedLeft, parsedRight); + } + +} diff --git a/fhir-server/src/main/java/au/csiro/pathling/sql/dates/TemporalDifferenceFunction.java b/fhir-server/src/main/java/au/csiro/pathling/sql/dates/TemporalDifferenceFunction.java new file mode 100644 index 0000000000..4775efc1dd --- /dev/null +++ b/fhir-server/src/main/java/au/csiro/pathling/sql/dates/TemporalDifferenceFunction.java @@ -0,0 +1,100 @@ +/* + * 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.sql.dates; + +import au.csiro.pathling.errors.InvalidUserInputError; +import au.csiro.pathling.sql.udf.SqlFunction3; +import com.google.common.collect.ImmutableMap; +import java.time.LocalDate; +import java.time.ZoneId; +import java.time.ZonedDateTime; +import java.time.format.DateTimeParseException; +import java.time.temporal.ChronoUnit; +import java.time.temporal.TemporalUnit; +import java.util.Map; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import org.apache.spark.sql.types.DataType; +import org.apache.spark.sql.types.DataTypes; +import org.springframework.context.annotation.Profile; +import org.springframework.stereotype.Component; + +/** + * Calculates the difference between two temporal values, returning an integer value using the + * requested unit. Used for the until function. + * + * @author John Grimes + */ +@Component +@Profile("core | unit-test") +public class TemporalDifferenceFunction implements SqlFunction3 { + + private static final long serialVersionUID = -7306741471632636471L; + public static final String FUNCTION_NAME = "date_diff"; + + static final Map CALENDAR_DURATION_TO_TEMPORAL = new ImmutableMap.Builder() + .put("year", ChronoUnit.YEARS) + .put("years", ChronoUnit.YEARS) + .put("month", ChronoUnit.MONTHS) + .put("months", ChronoUnit.MONTHS) + .put("day", ChronoUnit.DAYS) + .put("days", ChronoUnit.DAYS) + .put("hour", ChronoUnit.HOURS) + .put("hours", ChronoUnit.HOURS) + .put("minute", ChronoUnit.MINUTES) + .put("minutes", ChronoUnit.MINUTES) + .put("second", ChronoUnit.SECONDS) + .put("seconds", ChronoUnit.SECONDS) + .put("millisecond", ChronoUnit.MILLIS) + .put("milliseconds", ChronoUnit.MILLIS) + .build(); + + @Override + public String getName() { + return FUNCTION_NAME; + } + + @Override + public DataType getReturnType() { + return DataTypes.LongType; + } + + @Nullable + @Override + public Long call(@Nullable final String encodedFrom, @Nullable final String encodedTo, + @Nullable final String calendarDuration) throws Exception { + if (encodedFrom == null || encodedTo == null) { + return null; + } else if (calendarDuration == null) { + throw new InvalidUserInputError("Calendar duration must be provided"); + } + + final TemporalUnit temporalUnit = CALENDAR_DURATION_TO_TEMPORAL.get(calendarDuration); + + if (temporalUnit == null) { + throw new InvalidUserInputError("Invalid calendar duration: " + calendarDuration); + } + + final ZonedDateTime from = parse(encodedFrom); + final ZonedDateTime to = parse(encodedTo); + + return from.until(to, temporalUnit); + } + + private ZonedDateTime parse(final @Nonnull String encodedFrom) { + try { + return ZonedDateTime.parse(encodedFrom); + } catch (final DateTimeParseException e) { + return LocalDate.parse(encodedFrom).atStartOfDay(ZoneId.of("UTC")); + } + } + + public static boolean isValidCalendarDuration(final String literalValue) { + return CALENDAR_DURATION_TO_TEMPORAL.containsKey(literalValue); + } + +} diff --git a/fhir-server/src/main/java/au/csiro/pathling/sql/dates/date/DateAddDurationFunction.java b/fhir-server/src/main/java/au/csiro/pathling/sql/dates/date/DateAddDurationFunction.java new file mode 100644 index 0000000000..6d79cce4a6 --- /dev/null +++ b/fhir-server/src/main/java/au/csiro/pathling/sql/dates/date/DateAddDurationFunction.java @@ -0,0 +1,38 @@ +/* + * 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.sql.dates.date; + +import java.util.function.BiFunction; +import org.hl7.fhir.r4.model.DateType; +import org.hl7.fhir.r4.model.Quantity; +import org.springframework.context.annotation.Profile; +import org.springframework.stereotype.Component; + +/** + * Adds a duration to a date. + * + * @author John Grimes + */ +@Component +@Profile("core | unit-test") +public class DateAddDurationFunction extends DateArithmeticFunction { + + private static final long serialVersionUID = -5029179160644275584L; + + public static final String FUNCTION_NAME = "date_add_duration"; + + @Override + protected BiFunction getOperationFunction() { + return this::performAddition; + } + + @Override + public String getName() { + return FUNCTION_NAME; + } + +} diff --git a/fhir-server/src/main/java/au/csiro/pathling/sql/dates/date/DateArithmeticFunction.java b/fhir-server/src/main/java/au/csiro/pathling/sql/dates/date/DateArithmeticFunction.java new file mode 100644 index 0000000000..6251d1bb13 --- /dev/null +++ b/fhir-server/src/main/java/au/csiro/pathling/sql/dates/date/DateArithmeticFunction.java @@ -0,0 +1,32 @@ +/* + * 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.sql.dates.date; + +import au.csiro.pathling.sql.dates.TemporalArithmeticFunction; +import java.util.function.Function; +import org.hl7.fhir.r4.model.DateType; + +/** + * Base class for functions that perform arithmetic on dates. + * + * @author John Grimes + */ +public abstract class DateArithmeticFunction extends TemporalArithmeticFunction { + + private static final long serialVersionUID = 6759548804191034570L; + + @Override + protected Function parseEncodedValue() { + return DateType::new; + } + + @Override + protected Function encodeResult() { + return DateType::getValueAsString; + } + +} diff --git a/fhir-server/src/main/java/au/csiro/pathling/sql/dates/date/DateSubtractDurationFunction.java b/fhir-server/src/main/java/au/csiro/pathling/sql/dates/date/DateSubtractDurationFunction.java new file mode 100644 index 0000000000..957db94c53 --- /dev/null +++ b/fhir-server/src/main/java/au/csiro/pathling/sql/dates/date/DateSubtractDurationFunction.java @@ -0,0 +1,38 @@ +/* + * 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.sql.dates.date; + +import java.util.function.BiFunction; +import org.hl7.fhir.r4.model.DateType; +import org.hl7.fhir.r4.model.Quantity; +import org.springframework.context.annotation.Profile; +import org.springframework.stereotype.Component; + +/** + * Subtracts a duration from a date. + * + * @author John Grimes + */ +@Component +@Profile("core | unit-test") +public class DateSubtractDurationFunction extends DateArithmeticFunction { + + private static final long serialVersionUID = 5201879133976866457L; + + public static final String FUNCTION_NAME = "date_subtract_duration"; + + @Override + protected BiFunction getOperationFunction() { + return this::performSubtraction; + } + + @Override + public String getName() { + return FUNCTION_NAME; + } + +} diff --git a/fhir-server/src/main/java/au/csiro/pathling/sql/dates/datetime/DateTimeAddDurationFunction.java b/fhir-server/src/main/java/au/csiro/pathling/sql/dates/datetime/DateTimeAddDurationFunction.java new file mode 100644 index 0000000000..5f27afdf93 --- /dev/null +++ b/fhir-server/src/main/java/au/csiro/pathling/sql/dates/datetime/DateTimeAddDurationFunction.java @@ -0,0 +1,38 @@ +/* + * 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.sql.dates.datetime; + +import java.util.function.BiFunction; +import org.hl7.fhir.r4.model.DateTimeType; +import org.hl7.fhir.r4.model.Quantity; +import org.springframework.context.annotation.Profile; +import org.springframework.stereotype.Component; + +/** + * Adds a duration to a datetime. + * + * @author John Grimes + */ +@Component +@Profile("core | unit-test") +public class DateTimeAddDurationFunction extends DateTimeArithmeticFunction { + + private static final long serialVersionUID = 6922227603585641053L; + + public static final String FUNCTION_NAME = "datetime_add_duration"; + + @Override + protected BiFunction getOperationFunction() { + return this::performAddition; + } + + @Override + public String getName() { + return FUNCTION_NAME; + } + +} diff --git a/fhir-server/src/main/java/au/csiro/pathling/sql/dates/datetime/DateTimeArithmeticFunction.java b/fhir-server/src/main/java/au/csiro/pathling/sql/dates/datetime/DateTimeArithmeticFunction.java new file mode 100644 index 0000000000..e0e046462f --- /dev/null +++ b/fhir-server/src/main/java/au/csiro/pathling/sql/dates/datetime/DateTimeArithmeticFunction.java @@ -0,0 +1,33 @@ +/* + * 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.sql.dates.datetime; + +import au.csiro.pathling.sql.dates.TemporalArithmeticFunction; +import java.util.function.Function; +import org.hl7.fhir.r4.model.DateTimeType; + +/** + * Base class for functions that perform arithmetic on datetimes. + * + * @author John Grimes + */ +public abstract class DateTimeArithmeticFunction extends + TemporalArithmeticFunction { + + private static final long serialVersionUID = -6669722492626320119L; + + @Override + protected Function parseEncodedValue() { + return DateTimeType::new; + } + + @Override + protected Function encodeResult() { + return DateTimeType::getValueAsString; + } + +} diff --git a/fhir-server/src/main/java/au/csiro/pathling/sql/dates/datetime/DateTimeComparisonFunction.java b/fhir-server/src/main/java/au/csiro/pathling/sql/dates/datetime/DateTimeComparisonFunction.java new file mode 100644 index 0000000000..db30c0b2da --- /dev/null +++ b/fhir-server/src/main/java/au/csiro/pathling/sql/dates/datetime/DateTimeComparisonFunction.java @@ -0,0 +1,27 @@ +/* + * 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.sql.dates.datetime; + +import au.csiro.pathling.sql.dates.TemporalComparisonFunction; +import java.util.function.Function; +import org.hl7.fhir.r4.model.DateTimeType; + +/** + * Base class for functions that compare datetimes. + * + * @author John Grimes + */ +public abstract class DateTimeComparisonFunction extends TemporalComparisonFunction { + + private static final long serialVersionUID = -2449192480093120211L; + + @Override + protected Function parseEncodedValue() { + return DateTimeType::new; + } + +} diff --git a/fhir-server/src/main/java/au/csiro/pathling/sql/dates/datetime/DateTimeEqualsFunction.java b/fhir-server/src/main/java/au/csiro/pathling/sql/dates/datetime/DateTimeEqualsFunction.java new file mode 100644 index 0000000000..bec12a402c --- /dev/null +++ b/fhir-server/src/main/java/au/csiro/pathling/sql/dates/datetime/DateTimeEqualsFunction.java @@ -0,0 +1,38 @@ +/* + * 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.sql.dates.datetime; + +import java.util.function.BiFunction; +import org.hl7.fhir.r4.model.BaseDateTimeType; +import org.hl7.fhir.r4.model.DateTimeType; +import org.springframework.context.annotation.Profile; +import org.springframework.stereotype.Component; + +/** + * Determines the equality of two datetimes. + * + * @author John Grimes + */ +@Component +@Profile("core | unit-test") +public class DateTimeEqualsFunction extends DateTimeComparisonFunction { + + private static final long serialVersionUID = -8717420985056046161L; + + public static final String FUNCTION_NAME = "datetime_eq"; + + @Override + protected BiFunction getOperationFunction() { + return BaseDateTimeType::equalsUsingFhirPathRules; + } + + @Override + public String getName() { + return FUNCTION_NAME; + } + +} diff --git a/fhir-server/src/main/java/au/csiro/pathling/sql/dates/datetime/DateTimeGreaterThanFunction.java b/fhir-server/src/main/java/au/csiro/pathling/sql/dates/datetime/DateTimeGreaterThanFunction.java new file mode 100644 index 0000000000..e8c993df05 --- /dev/null +++ b/fhir-server/src/main/java/au/csiro/pathling/sql/dates/datetime/DateTimeGreaterThanFunction.java @@ -0,0 +1,40 @@ +/* + * 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.sql.dates.datetime; + +import java.util.function.BiFunction; +import javax.annotation.Nonnull; +import org.hl7.fhir.r4.model.BaseDateTimeType; +import org.hl7.fhir.r4.model.DateTimeType; +import org.springframework.context.annotation.Profile; +import org.springframework.stereotype.Component; + +/** + * Determines whether one datetime is after another. + * + * @author John Grimes + */ +@Component +@Profile("core | unit-test") +public class DateTimeGreaterThanFunction extends DateTimeComparisonFunction { + + private static final long serialVersionUID = 6648102436817402989L; + + public static final String FUNCTION_NAME = "datetime_gt"; + + @Nonnull + @Override + protected BiFunction getOperationFunction() { + return BaseDateTimeType::after; + } + + @Override + public String getName() { + return FUNCTION_NAME; + } + +} diff --git a/fhir-server/src/main/java/au/csiro/pathling/sql/dates/datetime/DateTimeGreaterThanOrEqualToFunction.java b/fhir-server/src/main/java/au/csiro/pathling/sql/dates/datetime/DateTimeGreaterThanOrEqualToFunction.java new file mode 100644 index 0000000000..63fe7eca61 --- /dev/null +++ b/fhir-server/src/main/java/au/csiro/pathling/sql/dates/datetime/DateTimeGreaterThanOrEqualToFunction.java @@ -0,0 +1,39 @@ +/* + * 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.sql.dates.datetime; + +import java.util.function.BiFunction; +import javax.annotation.Nonnull; +import org.hl7.fhir.r4.model.DateTimeType; +import org.springframework.context.annotation.Profile; +import org.springframework.stereotype.Component; + +/** + * Determines whether one datetime is after or at the same time as another. + * + * @author John Grimes + */ +@Component +@Profile("core | unit-test") +public class DateTimeGreaterThanOrEqualToFunction extends DateTimeComparisonFunction { + + private static final long serialVersionUID = -4680194983727139029L; + + public static final String FUNCTION_NAME = "datetime_gte"; + + @Nonnull + @Override + protected BiFunction getOperationFunction() { + return (left, right) -> left.after(right) || left.equalsUsingFhirPathRules(right); + } + + @Override + public String getName() { + return FUNCTION_NAME; + } + +} diff --git a/fhir-server/src/main/java/au/csiro/pathling/sql/dates/datetime/DateTimeLessThanFunction.java b/fhir-server/src/main/java/au/csiro/pathling/sql/dates/datetime/DateTimeLessThanFunction.java new file mode 100644 index 0000000000..4441f6aefb --- /dev/null +++ b/fhir-server/src/main/java/au/csiro/pathling/sql/dates/datetime/DateTimeLessThanFunction.java @@ -0,0 +1,40 @@ +/* + * 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.sql.dates.datetime; + +import java.util.function.BiFunction; +import javax.annotation.Nonnull; +import org.hl7.fhir.r4.model.BaseDateTimeType; +import org.hl7.fhir.r4.model.DateTimeType; +import org.springframework.context.annotation.Profile; +import org.springframework.stereotype.Component; + +/** + * Determines whether one datetime is before another. + * + * @author John Grimes + */ +@Component +@Profile("core | unit-test") +public class DateTimeLessThanFunction extends DateTimeComparisonFunction { + + private static final long serialVersionUID = -4688679934965980217L; + + public static final String FUNCTION_NAME = "datetime_lt"; + + @Nonnull + @Override + protected BiFunction getOperationFunction() { + return BaseDateTimeType::before; + } + + @Override + public String getName() { + return FUNCTION_NAME; + } + +} diff --git a/fhir-server/src/main/java/au/csiro/pathling/sql/dates/datetime/DateTimeLessThanOrEqualToFunction.java b/fhir-server/src/main/java/au/csiro/pathling/sql/dates/datetime/DateTimeLessThanOrEqualToFunction.java new file mode 100644 index 0000000000..1df0d1ad43 --- /dev/null +++ b/fhir-server/src/main/java/au/csiro/pathling/sql/dates/datetime/DateTimeLessThanOrEqualToFunction.java @@ -0,0 +1,39 @@ +/* + * 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.sql.dates.datetime; + +import java.util.function.BiFunction; +import javax.annotation.Nonnull; +import org.hl7.fhir.r4.model.DateTimeType; +import org.springframework.context.annotation.Profile; +import org.springframework.stereotype.Component; + +/** + * Determines whether one datetime is before or at the same time as another. + * + * @author John Grimes + */ +@Component +@Profile("core | unit-test") +public class DateTimeLessThanOrEqualToFunction extends DateTimeComparisonFunction { + + private static final long serialVersionUID = 787654631927909813L; + + public static final String FUNCTION_NAME = "datetime_lte"; + + @Nonnull + @Override + protected BiFunction getOperationFunction() { + return (left, right) -> left.before(right) || left.equalsUsingFhirPathRules(right); + } + + @Override + public String getName() { + return FUNCTION_NAME; + } + +} diff --git a/fhir-server/src/main/java/au/csiro/pathling/sql/dates/datetime/DateTimeSubtractDurationFunction.java b/fhir-server/src/main/java/au/csiro/pathling/sql/dates/datetime/DateTimeSubtractDurationFunction.java new file mode 100644 index 0000000000..7e044acdbd --- /dev/null +++ b/fhir-server/src/main/java/au/csiro/pathling/sql/dates/datetime/DateTimeSubtractDurationFunction.java @@ -0,0 +1,39 @@ +/* + * 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.sql.dates.datetime; + +import java.util.function.BiFunction; +import org.hl7.fhir.r4.model.DateTimeType; +import org.hl7.fhir.r4.model.Quantity; +import org.springframework.context.annotation.Profile; +import org.springframework.stereotype.Component; + +/** + * Subtracts a duration from a datetime. + * + * @author John Grimes + */ +@Component +@Profile("core | unit-test") +public class DateTimeSubtractDurationFunction extends DateTimeArithmeticFunction { + + private static final long serialVersionUID = -5922228168177608861L; + + public static final String FUNCTION_NAME = "datetime_subtract_duration"; + + @Override + protected BiFunction getOperationFunction() { + return this::performSubtraction; + } + + @Override + public String getName() { + return FUNCTION_NAME; + } + + +} diff --git a/fhir-server/src/main/java/au/csiro/pathling/sql/dates/time/TimeComparisonFunction.java b/fhir-server/src/main/java/au/csiro/pathling/sql/dates/time/TimeComparisonFunction.java new file mode 100644 index 0000000000..a169f1a3af --- /dev/null +++ b/fhir-server/src/main/java/au/csiro/pathling/sql/dates/time/TimeComparisonFunction.java @@ -0,0 +1,27 @@ +/* + * 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.sql.dates.time; + +import au.csiro.pathling.sql.dates.TemporalComparisonFunction; +import java.time.LocalTime; +import java.util.function.Function; + +/** + * Base class for functions that compare times. + * + * @author John Grimes + */ +public abstract class TimeComparisonFunction extends TemporalComparisonFunction { + + private static final long serialVersionUID = 3661335567427062952L; + + @Override + protected Function parseEncodedValue() { + return TimeFunction::parseEncodedTime; + } + +} diff --git a/fhir-server/src/main/java/au/csiro/pathling/sql/dates/time/TimeEqualsFunction.java b/fhir-server/src/main/java/au/csiro/pathling/sql/dates/time/TimeEqualsFunction.java new file mode 100644 index 0000000000..b3aa590dda --- /dev/null +++ b/fhir-server/src/main/java/au/csiro/pathling/sql/dates/time/TimeEqualsFunction.java @@ -0,0 +1,37 @@ +/* + * 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.sql.dates.time; + +import java.time.LocalTime; +import java.util.function.BiFunction; +import org.springframework.context.annotation.Profile; +import org.springframework.stereotype.Component; + +/** + * Determines the equality of two times. + * + * @author John Grimes + */ +@Component +@Profile("core | unit-test") +public class TimeEqualsFunction extends TimeComparisonFunction { + + private static final long serialVersionUID = -6607019777915271539L; + + public static final String FUNCTION_NAME = "time_eq"; + + @Override + protected BiFunction getOperationFunction() { + return LocalTime::equals; + } + + @Override + public String getName() { + return FUNCTION_NAME; + } + +} diff --git a/fhir-server/src/main/java/au/csiro/pathling/sql/dates/time/TimeFunction.java b/fhir-server/src/main/java/au/csiro/pathling/sql/dates/time/TimeFunction.java new file mode 100644 index 0000000000..e92b61a392 --- /dev/null +++ b/fhir-server/src/main/java/au/csiro/pathling/sql/dates/time/TimeFunction.java @@ -0,0 +1,30 @@ +/* + * 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.sql.dates.time; + +import java.time.LocalTime; +import java.util.regex.Pattern; +import javax.annotation.Nonnull; + +/** + * Common functionality relating to time operations. + * + * @author John Grimes + */ +abstract class TimeFunction { + + private static final Pattern HOURS_ONLY = Pattern.compile("^\\d{2}$"); + + @Nonnull + static LocalTime parseEncodedTime(@Nonnull final String encoded) { + // LocalDate will not successfully parse the HH format. + return HOURS_ONLY.matcher(encoded).matches() + ? LocalTime.parse(encoded + ":00") + : LocalTime.parse(encoded); + } + +} diff --git a/fhir-server/src/main/java/au/csiro/pathling/sql/dates/time/TimeGreaterThanFunction.java b/fhir-server/src/main/java/au/csiro/pathling/sql/dates/time/TimeGreaterThanFunction.java new file mode 100644 index 0000000000..bbc8ca1ca5 --- /dev/null +++ b/fhir-server/src/main/java/au/csiro/pathling/sql/dates/time/TimeGreaterThanFunction.java @@ -0,0 +1,37 @@ +/* + * 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.sql.dates.time; + +import java.time.LocalTime; +import java.util.function.BiFunction; +import org.springframework.context.annotation.Profile; +import org.springframework.stereotype.Component; + +/** + * Determines whether one time is after another. + * + * @author John Grimes + */ +@Component +@Profile("core | unit-test") +public class TimeGreaterThanFunction extends TimeComparisonFunction { + + private static final long serialVersionUID = 1785863110270729355L; + + public static final String FUNCTION_NAME = "time_gt"; + + @Override + protected BiFunction getOperationFunction() { + return LocalTime::isAfter; + } + + @Override + public String getName() { + return FUNCTION_NAME; + } + +} diff --git a/fhir-server/src/main/java/au/csiro/pathling/sql/dates/time/TimeGreaterThanOrEqualToFunction.java b/fhir-server/src/main/java/au/csiro/pathling/sql/dates/time/TimeGreaterThanOrEqualToFunction.java new file mode 100644 index 0000000000..c1f5a0462d --- /dev/null +++ b/fhir-server/src/main/java/au/csiro/pathling/sql/dates/time/TimeGreaterThanOrEqualToFunction.java @@ -0,0 +1,37 @@ +/* + * 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.sql.dates.time; + +import java.time.LocalTime; +import java.util.function.BiFunction; +import org.springframework.context.annotation.Profile; +import org.springframework.stereotype.Component; + +/** + * Determines whether one time is after or at the same time as another. + * + * @author John Grimes + */ +@Component +@Profile("core | unit-test") +public class TimeGreaterThanOrEqualToFunction extends TimeComparisonFunction { + + private static final long serialVersionUID = -8098751595303018323L; + + public static final String FUNCTION_NAME = "time_gte"; + + @Override + protected BiFunction getOperationFunction() { + return (a, b) -> a.isAfter(b) || a.equals(b); + } + + @Override + public String getName() { + return FUNCTION_NAME; + } + +} diff --git a/fhir-server/src/main/java/au/csiro/pathling/sql/dates/time/TimeLessThanFunction.java b/fhir-server/src/main/java/au/csiro/pathling/sql/dates/time/TimeLessThanFunction.java new file mode 100644 index 0000000000..0a6ae24d32 --- /dev/null +++ b/fhir-server/src/main/java/au/csiro/pathling/sql/dates/time/TimeLessThanFunction.java @@ -0,0 +1,37 @@ +/* + * 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.sql.dates.time; + +import java.time.LocalTime; +import java.util.function.BiFunction; +import org.springframework.context.annotation.Profile; +import org.springframework.stereotype.Component; + +/** + * Determines whether one time is before another. + * + * @author John Grimes + */ +@Component +@Profile("core | unit-test") +public class TimeLessThanFunction extends TimeComparisonFunction { + + private static final long serialVersionUID = 5957315745114053261L; + + public static final String FUNCTION_NAME = "time_lt"; + + @Override + protected BiFunction getOperationFunction() { + return LocalTime::isBefore; + } + + @Override + public String getName() { + return FUNCTION_NAME; + } + +} diff --git a/fhir-server/src/main/java/au/csiro/pathling/sql/dates/time/TimeLessThanOrEqualToFunction.java b/fhir-server/src/main/java/au/csiro/pathling/sql/dates/time/TimeLessThanOrEqualToFunction.java new file mode 100644 index 0000000000..7e85ac82e9 --- /dev/null +++ b/fhir-server/src/main/java/au/csiro/pathling/sql/dates/time/TimeLessThanOrEqualToFunction.java @@ -0,0 +1,37 @@ +/* + * 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.sql.dates.time; + +import java.time.LocalTime; +import java.util.function.BiFunction; +import org.springframework.context.annotation.Profile; +import org.springframework.stereotype.Component; + +/** + * Determines whether one time is before or at the same time as another. + * + * @author John Grimes + */ +@Component +@Profile("core | unit-test") +public class TimeLessThanOrEqualToFunction extends TimeComparisonFunction { + + private static final long serialVersionUID = -5929640258789711609L; + + public static final String FUNCTION_NAME = "time_lte"; + + @Override + protected BiFunction getOperationFunction() { + return (a, b) -> a.isBefore(b) || a.equals(b); + } + + @Override + public String getName() { + return FUNCTION_NAME; + } + +} diff --git a/fhir-server/src/main/java/au/csiro/pathling/sql/udf/SqlFunction.java b/fhir-server/src/main/java/au/csiro/pathling/sql/udf/SqlFunction.java new file mode 100644 index 0000000000..f593078c56 --- /dev/null +++ b/fhir-server/src/main/java/au/csiro/pathling/sql/udf/SqlFunction.java @@ -0,0 +1,31 @@ +/* + * 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.sql.udf; + +import org.apache.spark.sql.types.DataType; + +/** + * The interface that encapsulates meta data required for registration of a custom UDF function in + * Spark. + */ +public interface SqlFunction { + + /** + * Gets the name of the UDF. + * + * @return the name of the UDF function. + */ + String getName(); + + /** + * Gets the return type of the UDF + * + * @return the SQL type returned by the UDF. + */ + DataType getReturnType(); + +} diff --git a/fhir-server/src/main/java/au/csiro/pathling/sql/udf/SqlFunction1.java b/fhir-server/src/main/java/au/csiro/pathling/sql/udf/SqlFunction1.java new file mode 100644 index 0000000000..990ca34892 --- /dev/null +++ b/fhir-server/src/main/java/au/csiro/pathling/sql/udf/SqlFunction1.java @@ -0,0 +1,19 @@ +/* + * 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.sql.udf; + +import org.apache.spark.sql.api.java.UDF1; + +/** + * A registrable UDF function with one argument. + * + * @param the type of the argument. + * @param the type of the result. + */ +public interface SqlFunction1 extends SqlFunction, UDF1 { + +} diff --git a/fhir-server/src/main/java/au/csiro/pathling/sql/udf/SqlFunction2.java b/fhir-server/src/main/java/au/csiro/pathling/sql/udf/SqlFunction2.java new file mode 100644 index 0000000000..055ad09cd6 --- /dev/null +++ b/fhir-server/src/main/java/au/csiro/pathling/sql/udf/SqlFunction2.java @@ -0,0 +1,20 @@ +/* + * 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.sql.udf; + +import org.apache.spark.sql.api.java.UDF2; + +/** + * A registrable UDF function with two arguments. + * + * @param the type of the first argument. + * @param the type of the second argument. + * @param the type of the result. + */ +public interface SqlFunction2 extends SqlFunction, UDF2 { + +} diff --git a/fhir-server/src/main/java/au/csiro/pathling/sql/udf/SqlFunction3.java b/fhir-server/src/main/java/au/csiro/pathling/sql/udf/SqlFunction3.java new file mode 100644 index 0000000000..c41d03128c --- /dev/null +++ b/fhir-server/src/main/java/au/csiro/pathling/sql/udf/SqlFunction3.java @@ -0,0 +1,21 @@ +/* + * 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.sql.udf; + +import org.apache.spark.sql.api.java.UDF3; + +/** + * A registrable UDF function with three arguments. + * + * @param the type of the first argument. + * @param the type of the second argument. + * @param the type of the third argument. + * @param the type of the result. + */ +public interface SqlFunction3 extends SqlFunction, UDF3 { + +} diff --git a/terminology/src/main/java/au/csiro/pathling/sql/CodingToLiteral.java b/fhir-server/src/main/java/au/csiro/pathling/terminology/CodingToLiteral.java similarity index 63% rename from terminology/src/main/java/au/csiro/pathling/sql/CodingToLiteral.java rename to fhir-server/src/main/java/au/csiro/pathling/terminology/CodingToLiteral.java index 4f76fbc8e0..50f7ba642c 100644 --- a/terminology/src/main/java/au/csiro/pathling/sql/CodingToLiteral.java +++ b/fhir-server/src/main/java/au/csiro/pathling/terminology/CodingToLiteral.java @@ -4,21 +4,27 @@ * Software Licence Agreement. */ -package au.csiro.pathling.sql; +package au.csiro.pathling.terminology; import au.csiro.pathling.fhirpath.encoding.CodingEncoding; import au.csiro.pathling.fhirpath.literal.CodingLiteral; +import au.csiro.pathling.sql.udf.SqlFunction1; import javax.annotation.Nullable; import org.apache.spark.sql.Row; -import org.apache.spark.sql.api.java.UDF1; +import org.apache.spark.sql.types.DataType; +import org.apache.spark.sql.types.DataTypes; import org.hl7.fhir.r4.model.Coding; +import org.springframework.context.annotation.Profile; +import org.springframework.stereotype.Component; /** * Spark UDF to convert a Coding struct to a valid Coding literal string. * * @author John Grimes */ -public class CodingToLiteral implements UDF1 { +@Component +@Profile("core | unit-test") +public class CodingToLiteral implements SqlFunction1 { /** * The name of this function when used within SQL. @@ -27,6 +33,16 @@ public class CodingToLiteral implements UDF1 { private static final long serialVersionUID = -6274263255779613070L; + @Override + public String getName() { + return FUNCTION_NAME; + } + + @Override + public DataType getReturnType() { + return DataTypes.StringType; + } + @Override @Nullable public String call(@Nullable final Row row) { diff --git a/fhir-server/src/main/resources/application.yml b/fhir-server/src/main/resources/application.yml index 3b8dc796fa..28f3b73d80 100644 --- a/fhir-server/src/main/resources/application.yml +++ b/fhir-server/src/main/resources/application.yml @@ -42,18 +42,6 @@ pathling: # The subdirectory within the warehouse path used to read and write data. databaseName: default - # Configuration relating to accessing data hosted within Amazon Web Services. - aws: - # Public S3 buckets can be accessed by default, set this to false to access protected buckets. - anonymousAccess: true - - # Authentication details for connecting to protected Amazon S3 locations. - # accessKeyId: [AWS access key ID] - # secretAccessKey: [AWS secret access key] - - # The ARN of an IAM role to be assumed using STS. - # assumedRole: [ARN of IAM role] - terminology: # Enables the use of terminology functions. enabled: true @@ -200,3 +188,30 @@ spark: enabled: true scheduler: mode: FAIR + +# Use this section to set or override configuration relating to S3 configuration. +# See: https://hadoop.apache.org/docs/stable/hadoop-aws/tools/hadoop-aws/index.html +fs: + s3a: + aws: + # credentials: + # provider: org.apache.hadoop.fs.s3a.AnonymousAWSCredentialsProvider + # provider: org.apache.hadoop.fs.s3a.auth.AssumedRoleCredentialProvider + # + # For use with: SimpleAWSCredentialsProvider + # access: + # key: [access key] + # secret: + # key: [secret key] + # + # For use with: AssumedRoleCredentialProvider + # assumed: + # role: + # arn: [role ARN] + # + connection: + maximum: 100 + committer: + name: magic + magic: + enabled: true diff --git a/fhir-server/src/test/java/au/csiro/pathling/aggregate/DrillDownBuilderTest.java b/fhir-server/src/test/java/au/csiro/pathling/aggregate/DrillDownBuilderTest.java index 23e1986d19..9afd4ede83 100644 --- a/fhir-server/src/test/java/au/csiro/pathling/aggregate/DrillDownBuilderTest.java +++ b/fhir-server/src/test/java/au/csiro/pathling/aggregate/DrillDownBuilderTest.java @@ -83,10 +83,10 @@ static Stream parameters() { "(someElement) = @2020-01-01"), new TestParameters( new DateTimeType("2018-05-19T11:03:55.123Z"), - "(someElement) = @2018-05-19T11:03:55Z"), + "(someElement) = @2018-05-19T11:03:55.123Z"), new TestParameters( new InstantType("2018-05-19T11:03:55.123Z"), - "(someElement) = @2018-05-19T11:03:55Z"), + "(someElement) = @2018-05-19T11:03:55.123Z"), new TestParameters( new DecimalType("3.4"), "(someElement) = 3.4"), diff --git a/fhir-server/src/test/java/au/csiro/pathling/fhirpath/function/UntilFunctionTest.java b/fhir-server/src/test/java/au/csiro/pathling/fhirpath/function/UntilFunctionTest.java new file mode 100644 index 0000000000..1e78f5efd1 --- /dev/null +++ b/fhir-server/src/test/java/au/csiro/pathling/fhirpath/function/UntilFunctionTest.java @@ -0,0 +1,384 @@ +/* + * 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.fhirpath.function; + +import static au.csiro.pathling.test.assertions.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +import au.csiro.pathling.errors.InvalidUserInputError; +import au.csiro.pathling.fhirpath.FhirPath; +import au.csiro.pathling.fhirpath.NonLiteralPath; +import au.csiro.pathling.fhirpath.element.DatePath; +import au.csiro.pathling.fhirpath.element.DateTimePath; +import au.csiro.pathling.fhirpath.element.ElementPath; +import au.csiro.pathling.fhirpath.element.IntegerPath; +import au.csiro.pathling.fhirpath.element.ReferencePath; +import au.csiro.pathling.fhirpath.element.StringPath; +import au.csiro.pathling.fhirpath.literal.DateLiteralPath; +import au.csiro.pathling.fhirpath.literal.DateTimeLiteralPath; +import au.csiro.pathling.fhirpath.literal.StringLiteralPath; +import au.csiro.pathling.fhirpath.parser.ParserContext; +import au.csiro.pathling.test.builders.DatasetBuilder; +import au.csiro.pathling.test.builders.ElementPathBuilder; +import au.csiro.pathling.test.builders.ParserContextBuilder; +import ca.uhn.fhir.context.FhirContext; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableMap.Builder; +import java.text.ParseException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.List; +import java.util.stream.Stream; +import javax.annotation.Nonnull; +import lombok.Value; +import org.apache.spark.sql.Dataset; +import org.apache.spark.sql.Row; +import org.apache.spark.sql.SparkSession; +import org.apache.spark.sql.types.DataTypes; +import org.hl7.fhir.r4.model.Enumerations.FHIRDefinedType; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.api.TestInstance.Lifecycle; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; + +/** + * @author John Grimes + */ +@SpringBootTest +@TestInstance(Lifecycle.PER_CLASS) +@Tag("UnitTest") +class UntilFunctionTest { + + @Autowired + SparkSession spark; + + @Autowired + FhirContext fhirContext; + + static final String ID_ALIAS = "_abc123"; + static final String[] IDS = {"patient-1", "patient-2", "patient-3", "patient-4", "patient-5", + "patient-6"}; + + Dataset leftDataset() { + return new DatasetBuilder(spark) + .withIdColumn(ID_ALIAS) + .withColumn(DataTypes.StringType) + .withRow("patient-1", "2020-01-01T00:00:00Z") + .withRow("patient-2", "2020-01-01T00:00:00Z") + .withRow("patient-3", "2020-01-01") + .withRow("patient-4", null) + .withRow("patient-5", "2020-01-01T00:00:00Z") + .withRow("patient-6", null) + .build(); + } + + Dataset rightDataset() { + return new DatasetBuilder(spark) + .withIdColumn(ID_ALIAS) + .withColumn(DataTypes.StringType) + .withRow("patient-1", "2021-01-01T00:00:00Z") + .withRow("patient-2", "2021-01-01") + .withRow("patient-3", "2021-01-01T00:00:00Z") + .withRow("patient-4", "2021-01-01T00:00:00Z") + .withRow("patient-5", null) + .withRow("patient-6", null) + .build(); + } + + static final Object[] YEARS_RESULT = {1, 1, 1, null, null, null}; + static final Object[] MONTHS_RESULT = {12, 12, 12, null, null, null}; + static final Object[] DAYS_RESULT = {366, 366, 366, null, null, null}; + static final Object[] HOURS_RESULT = {8784, 8784, 8784, null, null, null}; + static final Object[] MINUTES_RESULT = {527040, 527040, 527040, null, null, null}; + static final Object[] SECONDS_RESULT = {31622400, 31622400, 31622400, null, null, null}; + private static final ImmutableMap CALENDAR_DURATION_TO_RESULT = new Builder() + .put("years", YEARS_RESULT) + .put("months", MONTHS_RESULT) + .put("days", DAYS_RESULT) + .put("hours", HOURS_RESULT) + .put("minutes", MINUTES_RESULT) + .put("seconds", SECONDS_RESULT) + .put("year", YEARS_RESULT) + .put("month", MONTHS_RESULT) + .put("day", DAYS_RESULT) + .put("hour", HOURS_RESULT) + .put("minute", MINUTES_RESULT) + .put("second", SECONDS_RESULT) + .build(); + + @Value + static class TestParameters { + + @Nonnull + String name; + + @Nonnull + NonLiteralPath input; + + @Nonnull + List arguments; + + @Nonnull + ParserContext context; + + @Nonnull + Dataset expectedResult; + + @Override + public String toString() { + return name; + } + + } + + @Nonnull + Stream parameters() { + final Collection parameters = new ArrayList<>(); + for (final String calendarDuration : CALENDAR_DURATION_TO_RESULT.keySet()) { + final ElementPath input = new ElementPathBuilder(spark) + .fhirType(FHIRDefinedType.DATETIME) + .dataset(leftDataset()) + .idAndValueColumns() + .singular(true) + .build(); + final ElementPath argument = new ElementPathBuilder(spark) + .fhirType(FHIRDefinedType.DATETIME) + .dataset(rightDataset()) + .idAndValueColumns() + .singular(true) + .build(); + final ParserContext context = new ParserContextBuilder(spark, fhirContext) + .groupingColumns(Collections.singletonList(input.getIdColumn())) + .build(); + final Dataset expectedResult = new DatasetBuilder(spark) + .withIdColumn(ID_ALIAS) + .withColumn(DataTypes.IntegerType) + .withIdValueRows(Arrays.asList(IDS), id -> { + final int index = Integer.parseInt(id.split("-")[1]) - 1; + final Object[] results = CALENDAR_DURATION_TO_RESULT.get(calendarDuration); + assertNotNull(results); + return results[index]; + }).build(); + final List arguments = List.of(argument, + StringLiteralPath.fromString(calendarDuration, input)); + parameters.add( + new TestParameters(calendarDuration, input, arguments, context, expectedResult)); + } + return parameters.stream(); + } + + @ParameterizedTest + @MethodSource("parameters") + void test(@Nonnull final TestParameters parameters) { + final NamedFunctionInput input = new NamedFunctionInput(parameters.getContext(), + parameters.getInput(), parameters.getArguments()); + final FhirPath result = NamedFunction.getInstance("until").invoke(input); + assertThat(result) + .isElementPath(IntegerPath.class) + .selectResult() + .hasRows(parameters.getExpectedResult()); + } + + @Test + void milliseconds() { + final Dataset leftDataset = new DatasetBuilder(spark) + .withIdColumn(ID_ALIAS) + .withColumn(DataTypes.StringType) + .withRow("patient-1", "2020-01-01") + .build(); + final Dataset rightDataset = new DatasetBuilder(spark) + .withIdColumn(ID_ALIAS) + .withColumn(DataTypes.StringType) + .withRow("patient-1", "2020-01-02") + .build(); + final ElementPath input = new ElementPathBuilder(spark) + .fhirType(FHIRDefinedType.DATE) + .dataset(leftDataset) + .idAndValueColumns() + .singular(true) + .build(); + final ElementPath argument = new ElementPathBuilder(spark) + .fhirType(FHIRDefinedType.DATE) + .dataset(rightDataset) + .idAndValueColumns() + .singular(true) + .build(); + final ParserContext context = new ParserContextBuilder(spark, fhirContext) + .groupingColumns(Collections.singletonList(input.getIdColumn())) + .build(); + final Dataset expectedResult = new DatasetBuilder(spark) + .withIdColumn(ID_ALIAS) + .withColumn(DataTypes.IntegerType) + .withRow("patient-1", 86400000) + .build(); + final List arguments1 = List.of(argument, + StringLiteralPath.fromString("millisecond", input)); + final List arguments2 = List.of(argument, + StringLiteralPath.fromString("millisecond", input)); + for (final List arguments : List.of(arguments1, arguments2)) { + final NamedFunctionInput functionInput = new NamedFunctionInput(context, input, arguments); + final FhirPath result = NamedFunction.getInstance("until").invoke(functionInput); + assertThat(result) + .isElementPath(IntegerPath.class) + .selectResult() + .hasRows(expectedResult); + } + } + + @Test + void dateLiteralArgument() throws ParseException { + final Dataset leftDataset = new DatasetBuilder(spark) + .withIdColumn(ID_ALIAS) + .withColumn(DataTypes.StringType) + .withRow("patient-1", "2020-01-01") + .build(); + final ElementPath input = new ElementPathBuilder(spark) + .fhirType(FHIRDefinedType.DATE) + .dataset(leftDataset) + .idAndValueColumns() + .singular(true) + .build(); + final DateLiteralPath argument = DateLiteralPath.fromString("2020-01-02", input); + final ParserContext context = new ParserContextBuilder(spark, fhirContext) + .groupingColumns(Collections.singletonList(input.getIdColumn())) + .build(); + final Dataset expectedResult = new DatasetBuilder(spark) + .withIdColumn(ID_ALIAS) + .withColumn(DataTypes.IntegerType) + .withRow("patient-1", 86400000) + .build(); + final List arguments = List.of(argument, + StringLiteralPath.fromString("millisecond", input)); + final NamedFunctionInput functionInput = new NamedFunctionInput(context, input, arguments); + final FhirPath result = NamedFunction.getInstance("until").invoke(functionInput); + assertThat(result) + .isElementPath(IntegerPath.class) + .selectResult() + .hasRows(expectedResult); + } + + @Test + void dateTimeLiteralArgument() throws ParseException { + final Dataset leftDataset = new DatasetBuilder(spark) + .withIdColumn(ID_ALIAS) + .withColumn(DataTypes.StringType) + .withRow("patient-1", "2020-01-01") + .build(); + final ElementPath input = new ElementPathBuilder(spark) + .fhirType(FHIRDefinedType.DATE) + .dataset(leftDataset) + .idAndValueColumns() + .singular(true) + .build(); + final DateTimeLiteralPath argument = DateTimeLiteralPath.fromString("2020-01-02T00:00:00Z", + input); + final ParserContext context = new ParserContextBuilder(spark, fhirContext) + .groupingColumns(Collections.singletonList(input.getIdColumn())) + .build(); + final Dataset expectedResult = new DatasetBuilder(spark) + .withIdColumn(ID_ALIAS) + .withColumn(DataTypes.IntegerType) + .withRow("patient-1", 86400000) + .build(); + final List arguments = List.of(argument, + StringLiteralPath.fromString("millisecond", input)); + final NamedFunctionInput functionInput = new NamedFunctionInput(context, input, arguments); + final FhirPath result = NamedFunction.getInstance("until").invoke(functionInput); + assertThat(result) + .isElementPath(IntegerPath.class) + .selectResult() + .hasRows(expectedResult); + } + + @Test + void invalidCalendarDuration() { + final Dataset leftDataset = new DatasetBuilder(spark) + .withIdColumn(ID_ALIAS) + .withColumn(DataTypes.StringType) + .withRow("patient-1", "2020-01-01") + .build(); + final ElementPath input = new ElementPathBuilder(spark) + .fhirType(FHIRDefinedType.DATE) + .dataset(leftDataset) + .idAndValueColumns() + .singular(true) + .build(); + + final DateTimePath argument = mock(DateTimePath.class); + when(argument.isSingular()).thenReturn(true); + + final NamedFunctionInput functionInput = new NamedFunctionInput(mock(ParserContext.class), + input, + List.of(argument, StringLiteralPath.fromString("nanosecond", input))); + final InvalidUserInputError error = assertThrows(InvalidUserInputError.class, + () -> NamedFunction.getInstance("until").invoke(functionInput)); + assertEquals("Invalid calendar duration: nanosecond", error.getMessage()); + } + + @Test + void wrongNumberOfArguments() { + final NamedFunctionInput input = new NamedFunctionInput(mock(ParserContext.class), + mock(DateTimePath.class), List.of(mock(DateTimePath.class))); + final InvalidUserInputError error = assertThrows(InvalidUserInputError.class, + () -> NamedFunction.getInstance("until").invoke(input)); + assertEquals("until function must have two arguments", error.getMessage()); + } + + @Test + void wrongInputType() { + final NamedFunctionInput input = new NamedFunctionInput(mock(ParserContext.class), + mock(StringPath.class), List.of(mock(DateTimePath.class), mock(StringLiteralPath.class))); + final InvalidUserInputError error = assertThrows(InvalidUserInputError.class, + () -> NamedFunction.getInstance("until").invoke(input)); + assertEquals("until function must be invoked on a DateTime or Date", error.getMessage()); + } + + @Test + void wrongArgumentType() { + final NamedFunctionInput input = new NamedFunctionInput(mock(ParserContext.class), + mock(DatePath.class), List.of(mock(ReferencePath.class), mock(StringLiteralPath.class))); + final InvalidUserInputError error = assertThrows(InvalidUserInputError.class, + () -> NamedFunction.getInstance("until").invoke(input)); + assertEquals("until function must have a DateTime or Date as the first argument", + error.getMessage()); + } + + @Test + void inputNotSingular() { + final DateTimePath input = mock(DateTimePath.class); + final NamedFunctionInput functionInput = new NamedFunctionInput(mock(ParserContext.class), + input, List.of(mock(DateTimeLiteralPath.class), + StringLiteralPath.fromString("nanosecond", input))); + final InvalidUserInputError error = assertThrows(InvalidUserInputError.class, + () -> NamedFunction.getInstance("until").invoke(functionInput)); + assertEquals("until function must be invoked on a singular path", error.getMessage()); + } + + @Test + void argumentNotSingular() { + final DateTimePath input = mock(DateTimePath.class); + when(input.isSingular()).thenReturn(true); + final NamedFunctionInput functionInput = new NamedFunctionInput(mock(ParserContext.class), + input, + List.of(mock(DateTimeLiteralPath.class), + StringLiteralPath.fromString("nanosecond", input))); + final InvalidUserInputError error = assertThrows(InvalidUserInputError.class, + () -> NamedFunction.getInstance("until").invoke(functionInput)); + assertEquals("until function must have the singular path as its first argument", + error.getMessage()); + } +} diff --git a/fhir-server/src/test/java/au/csiro/pathling/fhirpath/literal/CodingLiteralPathTest.java b/fhir-server/src/test/java/au/csiro/pathling/fhirpath/literal/CodingLiteralPathTest.java index 779ab8ed66..f386769bad 100644 --- a/fhir-server/src/test/java/au/csiro/pathling/fhirpath/literal/CodingLiteralPathTest.java +++ b/fhir-server/src/test/java/au/csiro/pathling/fhirpath/literal/CodingLiteralPathTest.java @@ -65,7 +65,7 @@ void roundTrip() { final CodingLiteralPath codingLiteralPath = CodingLiteralPath.fromString( expression, inputContext); - final Coding literalValue = codingLiteralPath.getLiteralValue(); + final Coding literalValue = codingLiteralPath.getValue(); assertEquals("http://snomed.info/sct", literalValue.getSystem()); assertEquals("http://snomed.info/sct/32506021000036107/version/20201231", literalValue.getVersion()); @@ -80,7 +80,7 @@ void roundTripNoVersion() { final String expression = "http://snomed.info/sct|166056000"; final CodingLiteralPath codingLiteralPath = CodingLiteralPath .fromString(expression, inputContext); - final Coding literalValue = codingLiteralPath.getLiteralValue(); + final Coding literalValue = codingLiteralPath.getValue(); assertEquals("http://snomed.info/sct", literalValue.getSystem()); assertNull(literalValue.getVersion()); assertEquals("166056000", literalValue.getCode()); @@ -98,7 +98,7 @@ void roundTripWithQuotedComponent() { + "|http://snomed.info/sct/32506021000036107/version/20201231"; final CodingLiteralPath codingLiteralPath = CodingLiteralPath .fromString(expression, inputContext); - final Coding literalValue = codingLiteralPath.getLiteralValue(); + final Coding literalValue = codingLiteralPath.getValue(); assertEquals("http://snomed.info/sct", literalValue.getSystem()); assertEquals("http://snomed.info/sct/32506021000036107/version/20201231", literalValue.getVersion()); @@ -117,7 +117,7 @@ void roundTripWithQuotedComponentWithComma() { "http://snomed.info/sct|'46,2'|http://snomed.info/sct/32506021000036107/version/20201231"; final CodingLiteralPath codingLiteralPath = CodingLiteralPath .fromString(expression, inputContext); - final Coding literalValue = codingLiteralPath.getLiteralValue(); + final Coding literalValue = codingLiteralPath.getValue(); assertEquals("http://snomed.info/sct", literalValue.getSystem()); assertEquals("http://snomed.info/sct/32506021000036107/version/20201231", literalValue.getVersion()); @@ -132,7 +132,7 @@ void roundTripWithQuotedComponentWithSingleQuote() { final String expression = "'Someone\\'s CodeSystem'|166056000"; final CodingLiteralPath codingLiteralPath = CodingLiteralPath .fromString(expression, inputContext); - final Coding literalValue = codingLiteralPath.getLiteralValue(); + final Coding literalValue = codingLiteralPath.getValue(); assertEquals("Someone's CodeSystem", literalValue.getSystem()); assertEquals("166056000", literalValue.getCode()); @@ -145,7 +145,7 @@ void roundTripWithQuotedComponentWithSpace() { final String expression = "'Some CodeSystem'|166056000"; final CodingLiteralPath codingLiteralPath = CodingLiteralPath .fromString(expression, inputContext); - final Coding literalValue = codingLiteralPath.getLiteralValue(); + final Coding literalValue = codingLiteralPath.getValue(); assertEquals("Some CodeSystem", literalValue.getSystem()); assertEquals("166056000", literalValue.getCode()); diff --git a/fhir-server/src/test/java/au/csiro/pathling/fhirpath/operator/ComparisonOperatorDateTest.java b/fhir-server/src/test/java/au/csiro/pathling/fhirpath/operator/ComparisonOperatorDateTest.java index 57e83513e2..ed0bd079a4 100644 --- a/fhir-server/src/test/java/au/csiro/pathling/fhirpath/operator/ComparisonOperatorDateTest.java +++ b/fhir-server/src/test/java/au/csiro/pathling/fhirpath/operator/ComparisonOperatorDateTest.java @@ -7,10 +7,10 @@ package au.csiro.pathling.fhirpath.operator; import static au.csiro.pathling.test.assertions.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertTrue; import au.csiro.pathling.fhirpath.FhirPath; -import au.csiro.pathling.fhirpath.element.BooleanPath; import au.csiro.pathling.fhirpath.element.ElementDefinition; import au.csiro.pathling.fhirpath.element.ElementPath; import au.csiro.pathling.fhirpath.parser.ParserContext; @@ -23,9 +23,11 @@ import java.util.Optional; import org.apache.spark.sql.Dataset; import org.apache.spark.sql.Row; +import org.apache.spark.sql.RowFactory; import org.apache.spark.sql.SparkSession; import org.apache.spark.sql.types.DataTypes; import org.hl7.fhir.r4.model.Enumerations.FHIRDefinedType; +import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Tag; import org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; @@ -45,72 +47,186 @@ class ComparisonOperatorDateTest { FhirContext fhirContext; static final String ID_ALIAS = "_abc123"; + private ElementPath left; + private ElementPath right; + private ParserContext parserContext; - @Test - void comparesDates() { - final Optional optionalLeftDefinition = FhirHelpers - .getChildOfResource(fhirContext, "MedicationRequest", "authoredOn"); - assertTrue(optionalLeftDefinition.isPresent()); - final ElementDefinition leftDefinition = optionalLeftDefinition.get(); + @BeforeEach + void setUp() { + final Optional optionalDefinition = FhirHelpers + .getChildOfResource(fhirContext, "Patient", "birthDate"); + assertTrue(optionalDefinition.isPresent()); + final ElementDefinition definition = optionalDefinition.get(); + assertTrue(definition.getFhirType().isPresent()); + assertEquals(FHIRDefinedType.DATE, definition.getFhirType().get()); final Dataset leftDataset = new DatasetBuilder(spark) .withIdColumn(ID_ALIAS) .withColumn(DataTypes.StringType) - .withRow("patient-1", "2013-06-10T15:33:22Z") - .withRow("patient-2", "2014-09-25T22:04:19+10:00") - .withRow("patient-3", "2018-05-18T11:03:55-05:00") + .withRow("patient-01", "2013-06-10") // Equal, years, months and days + .withRow("patient-02", "2013-06") // Equal, years and months + .withRow("patient-03", "2013") // Equal, years + .withRow("patient-04", "2013-06-01") // Different precisions + .withRow("patient-05", "2013-06-10") // Less than, years, months and days + .withRow("patient-06", "2013-06") // Less than, years and months + .withRow("patient-07", "2013") // Less than, years + .withRow("patient-08", "2013-06-10") // Greater than, years, months and days + .withRow("patient-09", "2013-06") // Greater than, years and months + .withRow("patient-10", "2013") // Greater than, years .build(); - final ElementPath leftPath = new ElementPathBuilder(spark) + left = new ElementPathBuilder(spark) .dataset(leftDataset) .idAndValueColumns() - .expression("authoredOn") + .expression("birthDate") .singular(true) - .definition(leftDefinition) + .definition(definition) .buildDefined(); - final Optional optionalRightDefinition = FhirHelpers - .getChildOfResource(fhirContext, "Condition", "onsetDateTime"); - assertTrue(optionalRightDefinition.isPresent()); - final ElementDefinition rightDefinition = optionalRightDefinition.get(); - final Dataset rightDataset = new DatasetBuilder(spark) .withIdColumn(ID_ALIAS) .withColumn(DataTypes.StringType) - .withRow("patient-1", "2013-06-10T12:33:22Z") - .withRow("patient-2", "2014-09-25T12:04:19Z") - .withRow("patient-3", "2018-05-19T11:03:55.123Z") + .withRow("patient-01", "2013-06-10") // Equal, years, months and days + .withRow("patient-02", "2013-06") // Equal, years and months + .withRow("patient-03", "2013") // Equal, years + .withRow("patient-04", "2013-06") // Different precisions + .withRow("patient-05", "2013-06-11") // Less than, years, months and days + .withRow("patient-06", "2013-07") // Less than, years and months + .withRow("patient-07", "2014") // Less than, years + .withRow("patient-08", "2013-05-10") // Greater than, years, months and days + .withRow("patient-09", "2012-06") // Greater than, years and months + .withRow("patient-10", "2012") // Greater than, years .build(); - final ElementPath rightPath = new ElementPathBuilder(spark) + right = new ElementPathBuilder(spark) .dataset(rightDataset) .idAndValueColumns() - .expression("reverseResolve(Condition.subject).onsetDateTime") + .expression("birthDate") .singular(true) - .definition(rightDefinition) + .definition(definition) .buildDefined(); - final ParserContext parserContext = new ParserContextBuilder(spark, fhirContext) - .groupingColumns(Collections.singletonList(leftPath.getIdColumn())) + parserContext = new ParserContextBuilder(spark, fhirContext) + .groupingColumns(Collections.singletonList(left.getIdColumn())) .build(); - final OperatorInput comparisonInput = new OperatorInput(parserContext, leftPath, - rightPath); + } + + @Test + void equals() { + final OperatorInput comparisonInput = new OperatorInput(parserContext, left, right); + final Operator lessThan = Operator.getInstance("="); + final FhirPath result = lessThan.invoke(comparisonInput); + + assertThat(result).selectOrderedResult().hasRows( + RowFactory.create("patient-01", true), // Equal, years, months and days + RowFactory.create("patient-02", true), // Equal, years and months + RowFactory.create("patient-03", true), // Equal, years + RowFactory.create("patient-04", true), // Different precisions + RowFactory.create("patient-05", false), // Less than, years, months and days + RowFactory.create("patient-06", false), // Less than, years and months + RowFactory.create("patient-07", false), // Less than, years + RowFactory.create("patient-08", false), // Greater than, years, months and days + RowFactory.create("patient-09", false), // Greater than, years and months + RowFactory.create("patient-10", false) // Greater than, years + ); + } + + @Test + void notEquals() { + final OperatorInput comparisonInput = new OperatorInput(parserContext, left, right); + final Operator lessThan = Operator.getInstance("!="); + final FhirPath result = lessThan.invoke(comparisonInput); + + assertThat(result).selectOrderedResult().hasRows( + RowFactory.create("patient-01", false), // Equal, years, months and days + RowFactory.create("patient-02", false), // Equal, years and months + RowFactory.create("patient-03", false), // Equal, years + RowFactory.create("patient-04", false), // Different precisions + RowFactory.create("patient-05", true), // Less than, years, months and days + RowFactory.create("patient-06", true), // Less than, years and months + RowFactory.create("patient-07", true), // Less than, years + RowFactory.create("patient-08", true), // Greater than, years, months and days + RowFactory.create("patient-09", true), // Greater than, years and months + RowFactory.create("patient-10", true) // Greater than, years + ); + } + + @Test + void lessThan() { + final OperatorInput comparisonInput = new OperatorInput(parserContext, left, right); + final Operator lessThan = Operator.getInstance("<"); + final FhirPath result = lessThan.invoke(comparisonInput); + + assertThat(result).selectOrderedResult().hasRows( + RowFactory.create("patient-01", false), // Equal, years, months and days + RowFactory.create("patient-02", false), // Equal, years and months + RowFactory.create("patient-03", false), // Equal, years + RowFactory.create("patient-04", false), // Different precisions + RowFactory.create("patient-05", true), // Less than, years, months and days + RowFactory.create("patient-06", true), // Less than, years and months + RowFactory.create("patient-07", true), // Less than, years + RowFactory.create("patient-08", false), // Greater than, years, months and days + RowFactory.create("patient-09", false), // Greater than, years and months + RowFactory.create("patient-10", false) // Greater than, years + ); + } + + @Test + void lessThanOrEqualTo() { + final OperatorInput comparisonInput = new OperatorInput(parserContext, left, right); final Operator lessThan = Operator.getInstance("<="); final FhirPath result = lessThan.invoke(comparisonInput); - assertTrue(result instanceof BooleanPath); - assertThat((ElementPath) result) - .hasExpression("authoredOn <= reverseResolve(Condition.subject).onsetDateTime") - .isSingular() - .hasFhirType(FHIRDefinedType.BOOLEAN); - - final Dataset expectedDataset = new DatasetBuilder(spark) - .withIdColumn() - .withColumn(DataTypes.BooleanType) - .withRow("patient-1", false) - .withRow("patient-2", true) - .withRow("patient-3", true) - .build(); - assertThat(result) - .selectOrderedResult() - .hasRows(expectedDataset); + assertThat(result).selectOrderedResult().hasRows( + RowFactory.create("patient-01", true), // Equal, years, months and days + RowFactory.create("patient-02", true), // Equal, years and months + RowFactory.create("patient-03", true), // Equal, years + RowFactory.create("patient-04", true), // Different precisions + RowFactory.create("patient-05", true), // Less than, years, months and days + RowFactory.create("patient-06", true), // Less than, years and months + RowFactory.create("patient-07", true), // Less than, years + RowFactory.create("patient-08", false), // Greater than, years, months and days + RowFactory.create("patient-09", false), // Greater than, years and months + RowFactory.create("patient-10", false) // Greater than, years + ); + } + + @Test + void greaterThan() { + final OperatorInput comparisonInput = new OperatorInput(parserContext, left, right); + final Operator lessThan = Operator.getInstance(">"); + final FhirPath result = lessThan.invoke(comparisonInput); + + assertThat(result).selectOrderedResult().hasRows( + RowFactory.create("patient-01", false), // Equal, years, months and days + RowFactory.create("patient-02", false), // Equal, years and months + RowFactory.create("patient-03", false), // Equal, years + RowFactory.create("patient-04", false), // Different precisions + RowFactory.create("patient-05", false), // Less than, years, months and days + RowFactory.create("patient-06", false), // Less than, years and months + RowFactory.create("patient-07", false), // Less than, years + RowFactory.create("patient-08", true), // Greater than, years, months and days + RowFactory.create("patient-09", true), // Greater than, years and months + RowFactory.create("patient-10", true) // Greater than, years + ); + } + + @Test + void greaterThanOrEqualTo() { + final OperatorInput comparisonInput = new OperatorInput(parserContext, left, right); + final Operator lessThan = Operator.getInstance(">="); + final FhirPath result = lessThan.invoke(comparisonInput); + + assertThat(result).selectOrderedResult().hasRows( + RowFactory.create("patient-01", true), // Equal, years, months and days + RowFactory.create("patient-02", true), // Equal, years and months + RowFactory.create("patient-03", true), // Equal, years + RowFactory.create("patient-04", true), // Different precisions + RowFactory.create("patient-05", false), // Less than, years, months and days + RowFactory.create("patient-06", false), // Less than, years and months + RowFactory.create("patient-07", false), // Less than, years + RowFactory.create("patient-08", true), // Greater than, years, months and days + RowFactory.create("patient-09", true), // Greater than, years and months + RowFactory.create("patient-10", true) // Greater than, years + ); } + } \ No newline at end of file diff --git a/fhir-server/src/test/java/au/csiro/pathling/fhirpath/operator/ComparisonOperatorDateTimeTest.java b/fhir-server/src/test/java/au/csiro/pathling/fhirpath/operator/ComparisonOperatorDateTimeTest.java new file mode 100644 index 0000000000..c92fd4d372 --- /dev/null +++ b/fhir-server/src/test/java/au/csiro/pathling/fhirpath/operator/ComparisonOperatorDateTimeTest.java @@ -0,0 +1,207 @@ +/* + * 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.fhirpath.operator; + +import static au.csiro.pathling.test.assertions.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import au.csiro.pathling.fhirpath.FhirPath; +import au.csiro.pathling.fhirpath.element.ElementDefinition; +import au.csiro.pathling.fhirpath.element.ElementPath; +import au.csiro.pathling.fhirpath.parser.ParserContext; +import au.csiro.pathling.test.builders.DatasetBuilder; +import au.csiro.pathling.test.builders.ElementPathBuilder; +import au.csiro.pathling.test.builders.ParserContextBuilder; +import au.csiro.pathling.test.helpers.FhirHelpers; +import ca.uhn.fhir.context.FhirContext; +import java.util.Collections; +import java.util.Optional; +import org.apache.spark.sql.Dataset; +import org.apache.spark.sql.Row; +import org.apache.spark.sql.RowFactory; +import org.apache.spark.sql.SparkSession; +import org.apache.spark.sql.types.DataTypes; +import org.hl7.fhir.r4.model.Enumerations.FHIRDefinedType; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; + +/** + * @author John Grimes + */ +@SpringBootTest +@Tag("UnitTest") +class ComparisonOperatorDateTimeTest { + + @Autowired + SparkSession spark; + + @Autowired + FhirContext fhirContext; + + static final String ID_ALIAS = "_abc123"; + private ElementPath left; + private ElementPath right; + private ParserContext parserContext; + + @BeforeEach + void setUp() { + final Optional optionalLeftDefinition = FhirHelpers + .getChildOfResource(fhirContext, "MedicationRequest", "authoredOn"); + assertTrue(optionalLeftDefinition.isPresent()); + final ElementDefinition leftDefinition = optionalLeftDefinition.get(); + assertTrue(leftDefinition.getFhirType().isPresent()); + assertEquals(FHIRDefinedType.DATETIME, leftDefinition.getFhirType().get()); + + final Dataset leftDataset = new DatasetBuilder(spark) + .withIdColumn(ID_ALIAS) + .withColumn(DataTypes.StringType) + .withRow("patient-1", "2013-06-10T15:33:22Z") // Equal, exact + .withRow("patient-2", "2013-06-10T15:33:22Z") // Equal, different time zones + .withRow("patient-3", "2013-06-10T15:33:22+00:00") // Equal, different time zone syntax + .withRow("patient-4", "2013-06-10T15:33:22.000Z") // Equal, different precisions + .withRow("patient-5", "2013-06-10T15:33:21.900Z") // Less than + .withRow("patient-6", "2013-06-11T15:33:22Z") // Greater than + .build(); + left = new ElementPathBuilder(spark) + .dataset(leftDataset) + .idAndValueColumns() + .expression("authoredOn") + .singular(true) + .definition(leftDefinition) + .buildDefined(); + + final Optional optionalRightDefinition = FhirHelpers + .getChildOfResource(fhirContext, "Condition", "onsetDateTime"); + assertTrue(optionalRightDefinition.isPresent()); + final ElementDefinition rightDefinition = optionalRightDefinition.get(); + assertTrue(rightDefinition.getFhirType().isPresent()); + assertEquals(FHIRDefinedType.DATETIME, rightDefinition.getFhirType().get()); + + final Dataset rightDataset = new DatasetBuilder(spark) + .withIdColumn(ID_ALIAS) + .withColumn(DataTypes.StringType) + .withRow("patient-1", "2013-06-10T15:33:22Z") // Equal, exact + .withRow("patient-2", "2013-06-11T01:33:22+10:00") // Equal, different time zones + .withRow("patient-3", "2013-06-10T15:33:22Z") // Equal, different time zone syntax + .withRow("patient-4", "2013-06-10T15:33:22Z") // Equal, different precisions + .withRow("patient-5", "2013-06-10T15:33:22Z") // Less than + .withRow("patient-6", "2013-06-10T15:33:22Z") // Greater than + .build(); + right = new ElementPathBuilder(spark) + .dataset(rightDataset) + .idAndValueColumns() + .expression("reverseResolve(Condition.subject).onsetDateTime") + .singular(true) + .definition(rightDefinition) + .buildDefined(); + + parserContext = new ParserContextBuilder(spark, fhirContext) + .groupingColumns(Collections.singletonList(left.getIdColumn())) + .build(); + } + + @Test + void equals() { + final OperatorInput comparisonInput = new OperatorInput(parserContext, left, right); + final Operator lessThan = Operator.getInstance("="); + final FhirPath result = lessThan.invoke(comparisonInput); + + assertThat(result).selectOrderedResult().hasRows( + RowFactory.create("patient-1", true), // Equal, exact + RowFactory.create("patient-2", true), // Equal, different time zones + RowFactory.create("patient-3", true), // Equal, different time zone syntax + RowFactory.create("patient-4", true), // Equal, different precisions + RowFactory.create("patient-5", false), // Less than + RowFactory.create("patient-6", false) // Greater than + ); + } + + @Test + void notEquals() { + final OperatorInput comparisonInput = new OperatorInput(parserContext, left, right); + final Operator lessThan = Operator.getInstance("!="); + final FhirPath result = lessThan.invoke(comparisonInput); + + assertThat(result).selectOrderedResult().hasRows( + RowFactory.create("patient-1", false), // Equal, exact + RowFactory.create("patient-2", false), // Equal, different time zones + RowFactory.create("patient-3", false), // Equal, different time zone syntax + RowFactory.create("patient-4", false), // Equal, different precisions + RowFactory.create("patient-5", true), // Less than + RowFactory.create("patient-6", true) // Greater than + ); + } + + @Test + void lessThan() { + final OperatorInput comparisonInput = new OperatorInput(parserContext, left, right); + final Operator lessThan = Operator.getInstance("<"); + final FhirPath result = lessThan.invoke(comparisonInput); + + assertThat(result).selectOrderedResult().hasRows( + RowFactory.create("patient-1", false), // Equal, exact + RowFactory.create("patient-2", false), // Equal, different time zones + RowFactory.create("patient-3", false), // Equal, different time zone syntax + RowFactory.create("patient-4", false), // Equal, different precisions + RowFactory.create("patient-5", true), // Less than + RowFactory.create("patient-6", false) // Greater than + ); + } + + @Test + void lessThanOrEqualTo() { + final OperatorInput comparisonInput = new OperatorInput(parserContext, left, right); + final Operator lessThan = Operator.getInstance("<="); + final FhirPath result = lessThan.invoke(comparisonInput); + + assertThat(result).selectOrderedResult().hasRows( + RowFactory.create("patient-1", true), // Equal, exact + RowFactory.create("patient-2", true), // Equal, different time zones + RowFactory.create("patient-3", true), // Equal, different time zone syntax + RowFactory.create("patient-4", true), // Equal, different precisions + RowFactory.create("patient-5", true), // Less than + RowFactory.create("patient-6", false) // Greater than + ); + } + + @Test + void greaterThan() { + final OperatorInput comparisonInput = new OperatorInput(parserContext, left, right); + final Operator lessThan = Operator.getInstance(">"); + final FhirPath result = lessThan.invoke(comparisonInput); + + assertThat(result).selectOrderedResult().hasRows( + RowFactory.create("patient-1", false), // Equal, exact + RowFactory.create("patient-2", false), // Equal, different time zones + RowFactory.create("patient-3", false), // Equal, different time zone syntax + RowFactory.create("patient-4", false), // Equal, different precisions + RowFactory.create("patient-5", false), // Less than + RowFactory.create("patient-6", true) // Greater than + ); + } + + @Test + void greaterThanOrEqualTo() { + final OperatorInput comparisonInput = new OperatorInput(parserContext, left, right); + final Operator lessThan = Operator.getInstance(">="); + final FhirPath result = lessThan.invoke(comparisonInput); + + assertThat(result).selectOrderedResult().hasRows( + RowFactory.create("patient-1", true), // Equal, exact + RowFactory.create("patient-2", true), // Equal, different time zones + RowFactory.create("patient-3", true), // Equal, different time zone syntax + RowFactory.create("patient-4", true), // Equal, different precisions + RowFactory.create("patient-5", false), // Less than + RowFactory.create("patient-6", true) // Greater than + ); + } + +} \ No newline at end of file diff --git a/fhir-server/src/test/java/au/csiro/pathling/fhirpath/operator/ComparisonOperatorQuantityTest.java b/fhir-server/src/test/java/au/csiro/pathling/fhirpath/operator/ComparisonOperatorQuantityTest.java new file mode 100644 index 0000000000..5450d8ea54 --- /dev/null +++ b/fhir-server/src/test/java/au/csiro/pathling/fhirpath/operator/ComparisonOperatorQuantityTest.java @@ -0,0 +1,251 @@ +/* + * 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.fhirpath.operator; + +import static au.csiro.pathling.test.assertions.Assertions.assertThat; +import static au.csiro.pathling.test.helpers.SparkHelpers.quantityStructType; +import static au.csiro.pathling.test.helpers.SparkHelpers.rowFromQuantity; + +import au.csiro.pathling.fhirpath.FhirPath; +import au.csiro.pathling.fhirpath.literal.QuantityLiteralPath; +import au.csiro.pathling.fhirpath.parser.ParserContext; +import au.csiro.pathling.test.builders.DatasetBuilder; +import au.csiro.pathling.test.builders.ElementPathBuilder; +import au.csiro.pathling.test.builders.ParserContextBuilder; +import au.csiro.pathling.test.helpers.TestHelpers; +import ca.uhn.fhir.context.FhirContext; +import java.util.Collections; +import org.apache.spark.sql.Dataset; +import org.apache.spark.sql.Row; +import org.apache.spark.sql.RowFactory; +import org.apache.spark.sql.SparkSession; +import org.fhir.ucum.UcumService; +import org.hl7.fhir.r4.model.Enumerations.FHIRDefinedType; +import org.hl7.fhir.r4.model.Quantity; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; + +@SpringBootTest +@Tag("UnitTest") +public class ComparisonOperatorQuantityTest { + + @Autowired + SparkSession spark; + + @Autowired + FhirContext fhirContext; + + @Autowired + UcumService ucumService; + + static final String ID_ALIAS = "_abc123"; + + FhirPath left; + FhirPath right; + ParserContext parserContext; + QuantityLiteralPath ucumQuantityLiteral1; + QuantityLiteralPath ucumQuantityLiteral2; + QuantityLiteralPath ucumQuantityLiteral3; + QuantityLiteralPath calendarDurationLiteral1; + QuantityLiteralPath calendarDurationLiteral2; + QuantityLiteralPath calendarDurationLiteral3; + + @BeforeEach + void setUp() { + final Quantity quantity1 = new Quantity(); + quantity1.setValue(500); + quantity1.setUnit("mg"); + quantity1.setSystem(TestHelpers.UCUM_URL); + quantity1.setCode("mg"); + + final Quantity quantity2 = new Quantity(); + quantity2.setValue(0.5); + quantity2.setUnit("g"); + quantity2.setSystem(TestHelpers.UCUM_URL); + quantity2.setCode("g"); + + final Quantity quantity3 = new Quantity(); + quantity3.setValue(1.8); + quantity3.setUnit("m"); + quantity3.setSystem(TestHelpers.UCUM_URL); + quantity3.setCode("m"); + + final Quantity quantity4 = new Quantity(); + quantity4.setValue(0.5); + quantity4.setUnit("g"); + quantity4.setSystem(TestHelpers.SNOMED_URL); + quantity4.setCode("258682000"); + + final Quantity quantity5 = new Quantity(); + quantity5.setValue(650); + quantity5.setUnit("mg"); + quantity5.setSystem(TestHelpers.UCUM_URL); + quantity5.setCode("mg"); + + final Quantity quantity6 = new Quantity(); + quantity6.setValue(30); + quantity6.setUnit("d"); + quantity6.setSystem(TestHelpers.UCUM_URL); + quantity6.setCode("d"); + + final Quantity quantity7 = new Quantity(); + quantity7.setValue(60); + quantity7.setUnit("s"); + quantity7.setSystem(TestHelpers.UCUM_URL); + quantity7.setCode("s"); + + final Quantity quantity8 = new Quantity(); + quantity8.setValue(1000); + quantity8.setUnit("ms"); + quantity8.setSystem(TestHelpers.UCUM_URL); + quantity8.setCode("ms"); + + final Quantity quantity9 = new Quantity(); + quantity9.setValue(0.2); + quantity9.setUnit("g"); + quantity9.setSystem(TestHelpers.UCUM_URL); + quantity9.setCode("g"); + + final Dataset leftDataset = new DatasetBuilder(spark) + .withIdColumn(ID_ALIAS) + .withStructTypeColumns(quantityStructType()) + .withRow("patient-01", rowFromQuantity(quantity1)) // 500 mg + .withRow("patient-02", rowFromQuantity(quantity1)) // 500 mg + .withRow("patient-03", rowFromQuantity(quantity1)) // 500 mg + .withRow("patient-04", rowFromQuantity(quantity5)) // 650 mg + .withRow("patient-05", null) + .withRow("patient-06", rowFromQuantity(quantity1)) // 500 mg + .withRow("patient-07", rowFromQuantity(quantity6)) // 30 d + .withRow("patient-08", rowFromQuantity(quantity7)) // 60 s + .withRow("patient-09", rowFromQuantity(quantity8)) // 1000 ms + .withRow("patient-10", rowFromQuantity(quantity9)) // 0.2 g + .buildWithStructValue(); + left = new ElementPathBuilder(spark) + .fhirType(FHIRDefinedType.QUANTITY) + .singular(true) + .dataset(leftDataset) + .idAndValueColumns() + .build(); + + final Dataset rightDataset = new DatasetBuilder(spark) + .withIdColumn(ID_ALIAS) + .withStructTypeColumns(quantityStructType()) + .withRow("patient-01", rowFromQuantity(quantity1)) // 500 mg + .withRow("patient-02", rowFromQuantity(quantity2)) // 0.5 g + .withRow("patient-03", rowFromQuantity(quantity3)) // 1.8 m + .withRow("patient-04", rowFromQuantity(quantity1)) // 500 mg + .withRow("patient-05", rowFromQuantity(quantity1)) // 500 mg + .withRow("patient-06", null) + .withRow("patient-07", rowFromQuantity(quantity6)) // 30 d + .withRow("patient-08", rowFromQuantity(quantity7)) // 60 s + .withRow("patient-09", rowFromQuantity(quantity8)) // 1000 ms + .withRow("patient-10", rowFromQuantity(quantity1)) // 500 mg + .buildWithStructValue(); + right = new ElementPathBuilder(spark) + .fhirType(FHIRDefinedType.QUANTITY) + .singular(true) + .dataset(rightDataset) + .idAndValueColumns() + .build(); + + ucumQuantityLiteral1 = QuantityLiteralPath.fromUcumString("500 'mg'", left, ucumService); + ucumQuantityLiteral2 = QuantityLiteralPath.fromUcumString("0.5 'g'", left, ucumService); + ucumQuantityLiteral3 = QuantityLiteralPath.fromUcumString("1.8 'm'", left, ucumService); + calendarDurationLiteral1 = QuantityLiteralPath.fromCalendarDurationString("30 days", left); + calendarDurationLiteral2 = QuantityLiteralPath.fromCalendarDurationString("60 seconds", left); + calendarDurationLiteral3 = QuantityLiteralPath.fromCalendarDurationString("1000 milliseconds", + left); + + parserContext = new ParserContextBuilder(spark, fhirContext) + .groupingColumns(Collections.singletonList(left.getIdColumn())) + .build(); + } + + @Test + void lessThan() { + final OperatorInput input = new OperatorInput(parserContext, left, right); + final Operator equalityOperator = Operator.getInstance("<"); + final FhirPath result = equalityOperator.invoke(input); + + assertThat(result).selectOrderedResult().hasRows( + RowFactory.create("patient-01", false), // 500 mg < 500 mg + RowFactory.create("patient-02", false), // 500 mg < 0.5 g + RowFactory.create("patient-03", null), // 500 mg < 1.8 m + RowFactory.create("patient-04", false), // 650 mg < 500 mg + RowFactory.create("patient-05", null), // {} < 500 mg + RowFactory.create("patient-06", null), // 500 mg < {} + RowFactory.create("patient-07", false), // 30 d < 30 d + RowFactory.create("patient-08", false), // 60 s < 60 s + RowFactory.create("patient-09", false), // 1000 ms < 1000 ms + RowFactory.create("patient-10", true) // 0.2 g < 500 mg + ); + } + + @Test + void lessThanOrEqualTo() { + final OperatorInput input = new OperatorInput(parserContext, left, right); + final Operator equalityOperator = Operator.getInstance("<="); + final FhirPath result = equalityOperator.invoke(input); + + assertThat(result).selectOrderedResult().hasRows( + RowFactory.create("patient-01", true), // 500 mg <= 500 mg + RowFactory.create("patient-02", true), // 500 mg <= 0.5 g + RowFactory.create("patient-03", null), // 500 mg <= 1.8 m + RowFactory.create("patient-04", false), // 650 mg <= 500 mg + RowFactory.create("patient-05", null), // {} <= 500 mg + RowFactory.create("patient-06", null), // 500 mg <= {} + RowFactory.create("patient-07", true), // 30 d <= 30 d + RowFactory.create("patient-08", true), // 60 s <= 60 s + RowFactory.create("patient-09", true), // 1000 ms <= 1000 ms + RowFactory.create("patient-10", true) // 0.2 g <= 500 mg + ); + } + + @Test + void greaterThanOrEqualTo() { + final OperatorInput input = new OperatorInput(parserContext, left, right); + final Operator equalityOperator = Operator.getInstance(">="); + final FhirPath result = equalityOperator.invoke(input); + + assertThat(result).selectOrderedResult().hasRows( + RowFactory.create("patient-01", true), // 500 mg >= 500 mg + RowFactory.create("patient-02", true), // 500 mg >= 0.5 g + RowFactory.create("patient-03", null), // 500 mg >= 1.8 m + RowFactory.create("patient-04", true), // 650 mg >= 500 mg + RowFactory.create("patient-05", null), // {} >= 500 mg + RowFactory.create("patient-06", null), // 500 mg >= {} + RowFactory.create("patient-07", true), // 30 d >= 30 d + RowFactory.create("patient-08", true), // 60 s >= 60 s + RowFactory.create("patient-09", true), // 1000 ms >= 1000 ms + RowFactory.create("patient-10", false) // 0.2 g >= 500 mg + ); + } + + @Test + void greaterThan() { + final OperatorInput input = new OperatorInput(parserContext, left, right); + final Operator equalityOperator = Operator.getInstance(">"); + final FhirPath result = equalityOperator.invoke(input); + + assertThat(result).selectOrderedResult().hasRows( + RowFactory.create("patient-01", false), // 500 mg > 500 mg + RowFactory.create("patient-02", false), // 500 mg > 0.5 g + RowFactory.create("patient-03", null), // 500 mg > 1.8 m + RowFactory.create("patient-04", true), // 650 mg > 500 mg + RowFactory.create("patient-05", null), // {} > 500 mg + RowFactory.create("patient-06", null), // 500 mg > {} + RowFactory.create("patient-07", false), // 30 d > 30 d + RowFactory.create("patient-08", false), // 60 s > 60 s + RowFactory.create("patient-09", false), // 1000 ms > 1000 ms + RowFactory.create("patient-10", false) // 0.2 g > 500 mg + ); + } + +} diff --git a/fhir-server/src/test/java/au/csiro/pathling/fhirpath/operator/ComparisonOperatorTimeTest.java b/fhir-server/src/test/java/au/csiro/pathling/fhirpath/operator/ComparisonOperatorTimeTest.java new file mode 100644 index 0000000000..8ac0731a04 --- /dev/null +++ b/fhir-server/src/test/java/au/csiro/pathling/fhirpath/operator/ComparisonOperatorTimeTest.java @@ -0,0 +1,232 @@ +/* + * 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.fhirpath.operator; + +import static au.csiro.pathling.test.assertions.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import au.csiro.pathling.fhirpath.FhirPath; +import au.csiro.pathling.fhirpath.element.ElementDefinition; +import au.csiro.pathling.fhirpath.element.ElementPath; +import au.csiro.pathling.fhirpath.parser.ParserContext; +import au.csiro.pathling.test.builders.DatasetBuilder; +import au.csiro.pathling.test.builders.ElementPathBuilder; +import au.csiro.pathling.test.builders.ParserContextBuilder; +import au.csiro.pathling.test.helpers.FhirHelpers; +import ca.uhn.fhir.context.FhirContext; +import java.util.Collections; +import java.util.Optional; +import org.apache.spark.sql.Dataset; +import org.apache.spark.sql.Row; +import org.apache.spark.sql.RowFactory; +import org.apache.spark.sql.SparkSession; +import org.apache.spark.sql.types.DataTypes; +import org.hl7.fhir.r4.model.Enumerations.FHIRDefinedType; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; + +/** + * @author John Grimes + */ +@SpringBootTest +@Tag("UnitTest") +class ComparisonOperatorTimeTest { + + @Autowired + SparkSession spark; + + @Autowired + FhirContext fhirContext; + + static final String ID_ALIAS = "_abc123"; + private ElementPath left; + private ElementPath right; + private ParserContext parserContext; + + @BeforeEach + void setUp() { + final Optional optionalDefinition = FhirHelpers + .getChildOfResource(fhirContext, "Observation", "valueTime"); + assertTrue(optionalDefinition.isPresent()); + final ElementDefinition definition = optionalDefinition.get(); + assertTrue(definition.getFhirType().isPresent()); + assertEquals(FHIRDefinedType.TIME, definition.getFhirType().get()); + + final Dataset leftDataset = new DatasetBuilder(spark) + .withIdColumn(ID_ALIAS) + .withColumn(DataTypes.StringType) + .withRow("patient-01", "03:15:36") // Equal, hours, minutes and seconds + .withRow("patient-02", "03:15") // Equal, hours and minutes + .withRow("patient-03", "03") // Equal, hours + .withRow("patient-04", "03:15:36") // Different precisions + .withRow("patient-05", "03:15:36") // Less than, hours, minutes and seconds + .withRow("patient-06", "03:15") // Less than, hours and minutes + .withRow("patient-07", "03") // Less than, hours + .withRow("patient-08", "03:15:36") // Greater than, hours, minutes and seconds + .withRow("patient-09", "03:15") // Greater than, hours and minutes + .withRow("patient-10", "03") // Greater than, hours + .build(); + left = new ElementPathBuilder(spark) + .dataset(leftDataset) + .idAndValueColumns() + .expression("valueTime") + .singular(true) + .definition(definition) + .buildDefined(); + + final Dataset rightDataset = new DatasetBuilder(spark) + .withIdColumn(ID_ALIAS) + .withColumn(DataTypes.StringType) + .withRow("patient-01", "03:15:36") // Equal, hours, minutes and seconds + .withRow("patient-02", "03:15") // Equal, hours and minutes + .withRow("patient-03", "03") // Equal, hours + .withRow("patient-04", "03:15") // Different precisions + .withRow("patient-05", "03:16:36") // Less than, hours, minutes and seconds + .withRow("patient-06", "03:16") // Less than, hours and minutes + .withRow("patient-07", "04") // Less than, hours + .withRow("patient-08", "02:15:36") // Greater than, hours, minutes and seconds + .withRow("patient-09", "03:14") // Greater than, hours and minutes + .withRow("patient-10", "01") // Greater than, hours + .build(); + right = new ElementPathBuilder(spark) + .dataset(rightDataset) + .idAndValueColumns() + .expression("valueTime") + .singular(true) + .definition(definition) + .buildDefined(); + + parserContext = new ParserContextBuilder(spark, fhirContext) + .groupingColumns(Collections.singletonList(left.getIdColumn())) + .build(); + } + + @Test + void equals() { + final OperatorInput comparisonInput = new OperatorInput(parserContext, left, right); + final Operator lessThan = Operator.getInstance("="); + final FhirPath result = lessThan.invoke(comparisonInput); + + assertThat(result).selectOrderedResult().hasRows( + RowFactory.create("patient-01", true), // Equal, hours, minutes and seconds + RowFactory.create("patient-02", true), // Equal, hours and minutes + RowFactory.create("patient-03", true), // Equal, hours + RowFactory.create("patient-04", false), // Different precisions + RowFactory.create("patient-05", false), // Less than, hours, minutes and seconds + RowFactory.create("patient-06", false), // Less than, hours and minutes + RowFactory.create("patient-07", false), // Less than, hours + RowFactory.create("patient-08", false), // Greater than, hours, minutes and seconds + RowFactory.create("patient-09", false), // Greater than, hours and minutes + RowFactory.create("patient-10", false) // Greater than, hours + ); + } + + @Test + void notEquals() { + final OperatorInput comparisonInput = new OperatorInput(parserContext, left, right); + final Operator lessThan = Operator.getInstance("!="); + final FhirPath result = lessThan.invoke(comparisonInput); + + assertThat(result).selectOrderedResult().hasRows( + RowFactory.create("patient-01", false), // Equal, hours, minutes and seconds + RowFactory.create("patient-02", false), // Equal, hours and minutes + RowFactory.create("patient-03", false), // Equal, hours + RowFactory.create("patient-04", true), // Different precisions + RowFactory.create("patient-05", true), // Less than, hours, minutes and seconds + RowFactory.create("patient-06", true), // Less than, hours and minutes + RowFactory.create("patient-07", true), // Less than, hours + RowFactory.create("patient-08", true), // Greater than, hours, minutes and seconds + RowFactory.create("patient-09", true), // Greater than, hours and minutes + RowFactory.create("patient-10", true) // Greater than, hours + ); + } + + @Test + void lessThan() { + final OperatorInput comparisonInput = new OperatorInput(parserContext, left, right); + final Operator lessThan = Operator.getInstance("<"); + final FhirPath result = lessThan.invoke(comparisonInput); + + assertThat(result).selectOrderedResult().hasRows( + RowFactory.create("patient-01", false), // Equal, hours, minutes and seconds + RowFactory.create("patient-02", false), // Equal, hours and minutes + RowFactory.create("patient-03", false), // Equal, hours + RowFactory.create("patient-04", false), // Different precisions + RowFactory.create("patient-05", true), // Less than, hours, minutes and seconds + RowFactory.create("patient-06", true), // Less than, hours and minutes + RowFactory.create("patient-07", true), // Less than, hours + RowFactory.create("patient-08", false), // Greater than, hours, minutes and seconds + RowFactory.create("patient-09", false), // Greater than, hours and minutes + RowFactory.create("patient-10", false) // Greater than, hours + ); + } + + @Test + void lessThanOrEqualTo() { + final OperatorInput comparisonInput = new OperatorInput(parserContext, left, right); + final Operator lessThan = Operator.getInstance("<="); + final FhirPath result = lessThan.invoke(comparisonInput); + + assertThat(result).selectOrderedResult().hasRows( + RowFactory.create("patient-01", true), // Equal, hours, minutes and seconds + RowFactory.create("patient-02", true), // Equal, hours and minutes + RowFactory.create("patient-03", true), // Equal, hours + RowFactory.create("patient-04", false), // Different precisions + RowFactory.create("patient-05", true), // Less than, hours, minutes and seconds + RowFactory.create("patient-06", true), // Less than, hours and minutes + RowFactory.create("patient-07", true), // Less than, hours + RowFactory.create("patient-08", false), // Greater than, hours, minutes and seconds + RowFactory.create("patient-09", false), // Greater than, hours and minutes + RowFactory.create("patient-10", false) // Greater than, hours + ); + } + + @Test + void greaterThan() { + final OperatorInput comparisonInput = new OperatorInput(parserContext, left, right); + final Operator lessThan = Operator.getInstance(">"); + final FhirPath result = lessThan.invoke(comparisonInput); + + assertThat(result).selectOrderedResult().hasRows( + RowFactory.create("patient-01", false), // Equal, hours, minutes and seconds + RowFactory.create("patient-02", false), // Equal, hours and minutes + RowFactory.create("patient-03", false), // Equal, hours + RowFactory.create("patient-04", true), // Different precisions + RowFactory.create("patient-05", false), // Less than, hours, minutes and seconds + RowFactory.create("patient-06", false), // Less than, hours and minutes + RowFactory.create("patient-07", false), // Less than, hours + RowFactory.create("patient-08", true), // Greater than, hours, minutes and seconds + RowFactory.create("patient-09", true), // Greater than, hours and minutes + RowFactory.create("patient-10", true) // Greater than, hours + ); + } + + @Test + void greaterThanOrEqualTo() { + final OperatorInput comparisonInput = new OperatorInput(parserContext, left, right); + final Operator lessThan = Operator.getInstance(">="); + final FhirPath result = lessThan.invoke(comparisonInput); + + assertThat(result).selectOrderedResult().hasRows( + RowFactory.create("patient-01", true), // Equal, hours, minutes and seconds + RowFactory.create("patient-02", true), // Equal, hours and minutes + RowFactory.create("patient-03", true), // Equal, hours + RowFactory.create("patient-04", true), // Different precisions + RowFactory.create("patient-05", false), // Less than, hours, minutes and seconds + RowFactory.create("patient-06", false), // Less than, hours and minutes + RowFactory.create("patient-07", false), // Less than, hours + RowFactory.create("patient-08", true), // Greater than, hours, minutes and seconds + RowFactory.create("patient-09", true), // Greater than, hours and minutes + RowFactory.create("patient-10", true) // Greater than, hours + ); + } + +} \ No newline at end of file diff --git a/fhir-server/src/test/java/au/csiro/pathling/fhirpath/operator/DateArithmeticTest.java b/fhir-server/src/test/java/au/csiro/pathling/fhirpath/operator/DateArithmeticTest.java new file mode 100644 index 0000000000..8323852618 --- /dev/null +++ b/fhir-server/src/test/java/au/csiro/pathling/fhirpath/operator/DateArithmeticTest.java @@ -0,0 +1,618 @@ +/* + * 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.fhirpath.operator; + +import static au.csiro.pathling.test.assertions.Assertions.assertThat; + +import au.csiro.pathling.fhirpath.FhirPath; +import au.csiro.pathling.fhirpath.element.ElementPath; +import au.csiro.pathling.fhirpath.literal.DateLiteralPath; +import au.csiro.pathling.fhirpath.literal.DateTimeLiteralPath; +import au.csiro.pathling.fhirpath.literal.QuantityLiteralPath; +import au.csiro.pathling.fhirpath.literal.TimeLiteralPath; +import au.csiro.pathling.fhirpath.parser.ParserContext; +import au.csiro.pathling.test.builders.DatasetBuilder; +import au.csiro.pathling.test.builders.ElementPathBuilder; +import au.csiro.pathling.test.builders.ParserContextBuilder; +import ca.uhn.fhir.context.FhirContext; +import java.text.ParseException; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.List; +import java.util.stream.Stream; +import javax.annotation.Nonnull; +import lombok.Value; +import org.apache.spark.sql.Dataset; +import org.apache.spark.sql.Row; +import org.apache.spark.sql.SparkSession; +import org.apache.spark.sql.types.DataTypes; +import org.hl7.fhir.r4.model.Enumerations.FHIRDefinedType; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.api.TestInstance.Lifecycle; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; + +@SpringBootTest +@TestInstance(Lifecycle.PER_CLASS) +@Tag("UnitTest") +public class DateArithmeticTest { + + @Autowired + SparkSession spark; + + @Autowired + FhirContext fhirContext; + + static final String ID_ALIAS = "_abc123"; + + @Value + static class TestParameters { + + @Nonnull + String name; + + @Nonnull + FhirPath left; + + @Nonnull + FhirPath right; + + @Nonnull + ParserContext context; + + @Nonnull + Operator operator; + + @Nonnull + Dataset expectedResult; + + @Override + public String toString() { + return name; + } + + } + + @Nonnull + Stream parameters() throws ParseException { + final List parameters = new ArrayList<>(); + + final Dataset dateTimeDataset = new DatasetBuilder(spark) + .withIdColumn(ID_ALIAS) + .withColumn(DataTypes.StringType) + .withRow("patient-1", "2015-02-07T13:28:17.000-05:00") + .withRow("patient-2", "2017-01-01T00:00:00Z") + .withRow("patient-3", "2025-06-21T00:15:00+10:00") + .build(); + final ElementPath dateTimePath = new ElementPathBuilder(spark) + .fhirType(FHIRDefinedType.DATETIME) + .dataset(dateTimeDataset) + .idAndValueColumns() + .singular(true) + .build(); + + final Dataset dateDataset = new DatasetBuilder(spark) + .withIdColumn(ID_ALIAS) + .withColumn(DataTypes.StringType) + .withRow("patient-1", "2015-02-07") + .withRow("patient-2", "2017-01-01") + .withRow("patient-3", "2025-06-21") + .build(); + final ElementPath datePath = new ElementPathBuilder(spark) + .fhirType(FHIRDefinedType.DATE) + .dataset(dateDataset) + .idAndValueColumns() + .singular(true) + .build(); + + final Dataset timeDataset = new DatasetBuilder(spark) + .withIdColumn(ID_ALIAS) + .withColumn(DataTypes.StringType) + .withRow("patient-1", "13:28:17") + .withRow("patient-2", "08:00") + .withRow("patient-3", "00") + .build(); + final ElementPath timePath = new ElementPathBuilder(spark) + .fhirType(FHIRDefinedType.TIME) + .dataset(timeDataset) + .idAndValueColumns() + .singular(true) + .build(); + + final DateTimeLiteralPath dateTimeLiteral = DateTimeLiteralPath.fromString( + "@2015-02-07T18:28:17+00:00", dateTimePath); + final DateLiteralPath dateLiteral = DateLiteralPath.fromString("@2015-02-07", datePath); + final TimeLiteralPath timeLiteral = TimeLiteralPath.fromString("@T08:00", timePath); + + final ParserContext context = new ParserContextBuilder(spark, fhirContext) + .groupingColumns(Collections.singletonList(dateTimePath.getIdColumn())) + .build(); + + parameters.addAll(dateTimeAddition(dateTimePath, context)); + parameters.addAll(dateTimeSubtraction(dateTimePath, context)); + parameters.addAll(dateAddition(datePath, context)); + parameters.addAll(dateSubtraction(datePath, context)); + parameters.addAll(dateTimeLiteralAddition(dateTimeLiteral, context)); + parameters.addAll(dateTimeLiteralSubtraction(dateTimeLiteral, context)); + parameters.addAll(dateLiteralAddition(dateLiteral, context)); + parameters.addAll(dateLiteralSubtraction(dateLiteral, context)); + + return parameters.stream(); + } + + Collection dateTimeAddition( + final FhirPath dateTimePath, final ParserContext context) { + final List parameters = new ArrayList<>(); + parameters.add(new TestParameters("DateTime + 10 years", dateTimePath, + QuantityLiteralPath.fromCalendarDurationString("10 years", dateTimePath), context, + Operator.getInstance("+"), + new DatasetBuilder(spark).withIdColumn(ID_ALIAS).withColumn(DataTypes.StringType) + .withRow("patient-1", "2025-02-07T13:28:17.000-05:00") + .withRow("patient-2", "2027-01-01T00:00:00Z") + .withRow("patient-3", "2035-06-21T00:15:00+10:00") + .build()) + ); + + parameters.add(new TestParameters("DateTime + 9 months", dateTimePath, + QuantityLiteralPath.fromCalendarDurationString("9 months", dateTimePath), context, + Operator.getInstance("+"), + new DatasetBuilder(spark).withIdColumn(ID_ALIAS).withColumn(DataTypes.StringType) + .withRow("patient-1", "2015-11-07T13:28:17.000-05:00") + .withRow("patient-2", "2017-10-01T00:00:00Z") + .withRow("patient-3", "2026-03-21T00:15:00+10:00") + .build()) + ); + + parameters.add(new TestParameters("DateTime + 30 days", dateTimePath, + QuantityLiteralPath.fromCalendarDurationString("30 days", dateTimePath), context, + Operator.getInstance("+"), + new DatasetBuilder(spark).withIdColumn(ID_ALIAS).withColumn(DataTypes.StringType) + .withRow("patient-1", "2015-03-09T13:28:17.000-05:00") + .withRow("patient-2", "2017-01-31T00:00:00Z") + .withRow("patient-3", "2025-07-21T00:15:00+10:00") + .build()) + ); + + parameters.add(new TestParameters("DateTime + 12 hours", dateTimePath, + QuantityLiteralPath.fromCalendarDurationString("12 hours", dateTimePath), context, + Operator.getInstance("+"), + new DatasetBuilder(spark).withIdColumn(ID_ALIAS).withColumn(DataTypes.StringType) + .withRow("patient-1", "2015-02-08T01:28:17.000-05:00") + .withRow("patient-2", "2017-01-01T12:00:00Z") + .withRow("patient-3", "2025-06-21T12:15:00+10:00") + .build()) + ); + + parameters.add(new TestParameters("DateTime + 30 minutes", dateTimePath, + QuantityLiteralPath.fromCalendarDurationString("30 minutes", dateTimePath), context, + Operator.getInstance("+"), + new DatasetBuilder(spark).withIdColumn(ID_ALIAS).withColumn(DataTypes.StringType) + .withRow("patient-1", "2015-02-07T13:58:17.000-05:00") + .withRow("patient-2", "2017-01-01T00:30:00Z") + .withRow("patient-3", "2025-06-21T00:45:00+10:00") + .build()) + ); + + parameters.add(new TestParameters("DateTime + 10 seconds", dateTimePath, + QuantityLiteralPath.fromCalendarDurationString("10 seconds", dateTimePath), context, + Operator.getInstance("+"), + new DatasetBuilder(spark).withIdColumn(ID_ALIAS).withColumn(DataTypes.StringType) + .withRow("patient-1", "2015-02-07T13:28:27.000-05:00") + .withRow("patient-2", "2017-01-01T00:00:10Z") + .withRow("patient-3", "2025-06-21T00:15:10+10:00") + .build()) + ); + + parameters.add(new TestParameters("DateTime + 300 milliseconds", dateTimePath, + QuantityLiteralPath.fromCalendarDurationString("300 milliseconds", dateTimePath), context, + Operator.getInstance("+"), + new DatasetBuilder(spark).withIdColumn(ID_ALIAS).withColumn(DataTypes.StringType) + .withRow("patient-1", "2015-02-07T13:28:17.300-05:00") + .withRow("patient-2", "2017-01-01T00:00:00Z") + .withRow("patient-3", "2025-06-21T00:15:00+10:00") + .build()) + ); + return parameters; + } + + Collection dateTimeSubtraction( + final FhirPath dateTimePath, final ParserContext context) { + final List parameters = new ArrayList<>(); + parameters.add(new TestParameters("DateTime - 10 years", dateTimePath, + QuantityLiteralPath.fromCalendarDurationString("10 years", dateTimePath), context, + Operator.getInstance("-"), + new DatasetBuilder(spark).withIdColumn(ID_ALIAS).withColumn(DataTypes.StringType) + .withRow("patient-1", "2005-02-07T13:28:17.000-05:00") + .withRow("patient-2", "2007-01-01T00:00:00Z") + .withRow("patient-3", "2015-06-21T00:15:00+10:00") + .build()) + ); + + parameters.add(new TestParameters("DateTime - 9 months", dateTimePath, + QuantityLiteralPath.fromCalendarDurationString("9 months", dateTimePath), context, + Operator.getInstance("-"), + new DatasetBuilder(spark).withIdColumn(ID_ALIAS).withColumn(DataTypes.StringType) + .withRow("patient-1", "2014-05-07T13:28:17.000-05:00") + .withRow("patient-2", "2016-04-01T00:00:00Z") + .withRow("patient-3", "2024-09-21T00:15:00+10:00") + .build()) + ); + + parameters.add(new TestParameters("DateTime - 30 days", dateTimePath, + QuantityLiteralPath.fromCalendarDurationString("30 days", dateTimePath), context, + Operator.getInstance("-"), + new DatasetBuilder(spark).withIdColumn(ID_ALIAS).withColumn(DataTypes.StringType) + .withRow("patient-1", "2015-01-08T13:28:17.000-05:00") + .withRow("patient-2", "2016-12-02T00:00:00Z") + .withRow("patient-3", "2025-05-22T00:15:00+10:00") + .build()) + ); + + parameters.add(new TestParameters("DateTime - 12 hours", dateTimePath, + QuantityLiteralPath.fromCalendarDurationString("12 hours", dateTimePath), context, + Operator.getInstance("-"), + new DatasetBuilder(spark).withIdColumn(ID_ALIAS).withColumn(DataTypes.StringType) + .withRow("patient-1", "2015-02-07T01:28:17.000-05:00") + .withRow("patient-2", "2016-12-31T12:00:00Z") + .withRow("patient-3", "2025-06-20T12:15:00+10:00") + .build()) + ); + + parameters.add(new TestParameters("DateTime - 30 minutes", dateTimePath, + QuantityLiteralPath.fromCalendarDurationString("30 minutes", dateTimePath), context, + Operator.getInstance("-"), + new DatasetBuilder(spark).withIdColumn(ID_ALIAS).withColumn(DataTypes.StringType) + .withRow("patient-1", "2015-02-07T12:58:17.000-05:00") + .withRow("patient-2", "2016-12-31T23:30:00Z") + .withRow("patient-3", "2025-06-20T23:45:00+10:00") + .build()) + ); + + parameters.add(new TestParameters("DateTime - 10 seconds", dateTimePath, + QuantityLiteralPath.fromCalendarDurationString("10 seconds", dateTimePath), context, + Operator.getInstance("-"), + new DatasetBuilder(spark).withIdColumn(ID_ALIAS).withColumn(DataTypes.StringType) + .withRow("patient-1", "2015-02-07T13:28:07.000-05:00") + .withRow("patient-2", "2016-12-31T23:59:50Z") + .withRow("patient-3", "2025-06-21T00:14:50+10:00") + .build()) + ); + + parameters.add(new TestParameters("DateTime - 300 milliseconds", dateTimePath, + QuantityLiteralPath.fromCalendarDurationString("300 milliseconds", dateTimePath), context, + Operator.getInstance("-"), + new DatasetBuilder(spark).withIdColumn(ID_ALIAS).withColumn(DataTypes.StringType) + .withRow("patient-1", "2015-02-07T13:28:16.700-05:00") + .withRow("patient-2", "2016-12-31T23:59:59Z") + .withRow("patient-3", "2025-06-21T00:14:59+10:00") + .build()) + ); + return parameters; + } + + Collection dateAddition( + final FhirPath datePath, final ParserContext context) { + final List parameters = new ArrayList<>(); + parameters.add(new TestParameters("Date + 10 years", datePath, + QuantityLiteralPath.fromCalendarDurationString("10 years", datePath), context, + Operator.getInstance("+"), + new DatasetBuilder(spark).withIdColumn(ID_ALIAS).withColumn(DataTypes.StringType) + .withRow("patient-1", "2025-02-07") + .withRow("patient-2", "2027-01-01") + .withRow("patient-3", "2035-06-21") + .build()) + ); + + parameters.add(new TestParameters("Date + 9 months", datePath, + QuantityLiteralPath.fromCalendarDurationString("9 months", datePath), context, + Operator.getInstance("+"), + new DatasetBuilder(spark).withIdColumn(ID_ALIAS).withColumn(DataTypes.StringType) + .withRow("patient-1", "2015-11-07") + .withRow("patient-2", "2017-10-01") + .withRow("patient-3", "2026-03-21") + .build()) + ); + + parameters.add(new TestParameters("Date + 30 days", datePath, + QuantityLiteralPath.fromCalendarDurationString("30 days", datePath), context, + Operator.getInstance("+"), + new DatasetBuilder(spark).withIdColumn(ID_ALIAS).withColumn(DataTypes.StringType) + .withRow("patient-1", "2015-03-09") + .withRow("patient-2", "2017-01-31") + .withRow("patient-3", "2025-07-21") + .build()) + ); + + return parameters; + } + + Collection dateSubtraction( + final FhirPath datePath, final ParserContext context) { + final List parameters = new ArrayList<>(); + parameters.add(new TestParameters("Date - 10 years", datePath, + QuantityLiteralPath.fromCalendarDurationString("10 years", datePath), context, + Operator.getInstance("-"), + new DatasetBuilder(spark).withIdColumn(ID_ALIAS).withColumn(DataTypes.StringType) + .withRow("patient-1", "2005-02-07") + .withRow("patient-2", "2007-01-01") + .withRow("patient-3", "2015-06-21") + .build()) + ); + + parameters.add(new TestParameters("Date - 9 months", datePath, + QuantityLiteralPath.fromCalendarDurationString("9 months", datePath), context, + Operator.getInstance("-"), + new DatasetBuilder(spark).withIdColumn(ID_ALIAS).withColumn(DataTypes.StringType) + .withRow("patient-1", "2014-05-07") + .withRow("patient-2", "2016-04-01") + .withRow("patient-3", "2024-09-21") + .build()) + ); + + parameters.add(new TestParameters("Date - 30 days", datePath, + QuantityLiteralPath.fromCalendarDurationString("30 days", datePath), context, + Operator.getInstance("-"), + new DatasetBuilder(spark).withIdColumn(ID_ALIAS).withColumn(DataTypes.StringType) + .withRow("patient-1", "2015-01-08") + .withRow("patient-2", "2016-12-02") + .withRow("patient-3", "2025-05-22") + .build()) + ); + + return parameters; + } + + Collection dateTimeLiteralAddition( + final FhirPath dateTimeLiteralPath, final ParserContext context) { + final List parameters = new ArrayList<>(); + parameters.add(new TestParameters("@2015-02-07T18:28:17+00:00 + 10 years", dateTimeLiteralPath, + QuantityLiteralPath.fromCalendarDurationString("10 years", dateTimeLiteralPath), context, + Operator.getInstance("+"), + new DatasetBuilder(spark).withIdColumn(ID_ALIAS).withColumn(DataTypes.StringType) + .withRow("patient-1", "2025-02-07T18:28:17+00:00") + .withRow("patient-2", "2025-02-07T18:28:17+00:00") + .withRow("patient-3", "2025-02-07T18:28:17+00:00") + .build()) + ); + + parameters.add(new TestParameters("@2015-02-07T18:28:17+00:00 + 9 months", dateTimeLiteralPath, + QuantityLiteralPath.fromCalendarDurationString("9 months", dateTimeLiteralPath), context, + Operator.getInstance("+"), + new DatasetBuilder(spark).withIdColumn(ID_ALIAS).withColumn(DataTypes.StringType) + .withRow("patient-1", "2015-11-07T18:28:17+00:00") + .withRow("patient-2", "2015-11-07T18:28:17+00:00") + .withRow("patient-3", "2015-11-07T18:28:17+00:00") + .build()) + ); + + parameters.add(new TestParameters("@2015-02-07T18:28:17+00:00 + 30 days", dateTimeLiteralPath, + QuantityLiteralPath.fromCalendarDurationString("30 days", dateTimeLiteralPath), context, + Operator.getInstance("+"), + new DatasetBuilder(spark).withIdColumn(ID_ALIAS).withColumn(DataTypes.StringType) + .withRow("patient-1", "2015-03-09T18:28:17+00:00") + .withRow("patient-2", "2015-03-09T18:28:17+00:00") + .withRow("patient-3", "2015-03-09T18:28:17+00:00") + .build()) + ); + + parameters.add(new TestParameters("@2015-02-07T18:28:17+00:00 + 12 hours", dateTimeLiteralPath, + QuantityLiteralPath.fromCalendarDurationString("12 hours", dateTimeLiteralPath), context, + Operator.getInstance("+"), + new DatasetBuilder(spark).withIdColumn(ID_ALIAS).withColumn(DataTypes.StringType) + .withRow("patient-1", "2015-02-08T06:28:17+00:00") + .withRow("patient-2", "2015-02-08T06:28:17+00:00") + .withRow("patient-3", "2015-02-08T06:28:17+00:00") + .build()) + ); + + parameters.add( + new TestParameters("@2015-02-07T18:28:17+00:00 + 30 minutes", dateTimeLiteralPath, + QuantityLiteralPath.fromCalendarDurationString("30 minutes", dateTimeLiteralPath), + context, + Operator.getInstance("+"), + new DatasetBuilder(spark).withIdColumn(ID_ALIAS).withColumn(DataTypes.StringType) + .withRow("patient-1", "2015-02-07T18:58:17+00:00") + .withRow("patient-2", "2015-02-07T18:58:17+00:00") + .withRow("patient-3", "2015-02-07T18:58:17+00:00") + .build()) + ); + + parameters.add( + new TestParameters("@2015-02-07T18:28:17+00:00 + 10 seconds", dateTimeLiteralPath, + QuantityLiteralPath.fromCalendarDurationString("10 seconds", dateTimeLiteralPath), + context, + Operator.getInstance("+"), + new DatasetBuilder(spark).withIdColumn(ID_ALIAS).withColumn(DataTypes.StringType) + .withRow("patient-1", "2015-02-07T18:28:27+00:00") + .withRow("patient-2", "2015-02-07T18:28:27+00:00") + .withRow("patient-3", "2015-02-07T18:28:27+00:00") + .build()) + ); + + parameters.add( + new TestParameters("@2015-02-07T18:28:17+00:00 + 300 milliseconds", dateTimeLiteralPath, + QuantityLiteralPath.fromCalendarDurationString("300 milliseconds", dateTimeLiteralPath), + context, + Operator.getInstance("+"), + new DatasetBuilder(spark).withIdColumn(ID_ALIAS).withColumn(DataTypes.StringType) + .withRow("patient-1", "2015-02-07T18:28:17+00:00") + .withRow("patient-2", "2015-02-07T18:28:17+00:00") + .withRow("patient-3", "2015-02-07T18:28:17+00:00") + .build()) + ); + + return parameters; + } + + Collection dateTimeLiteralSubtraction( + final FhirPath dateTimeLiteralPath, final ParserContext context) { + final List parameters = new ArrayList<>(); + parameters.add(new TestParameters("@2015-02-07T18:28:17+00:00 - 10 years", dateTimeLiteralPath, + QuantityLiteralPath.fromCalendarDurationString("10 years", dateTimeLiteralPath), context, + Operator.getInstance("-"), + new DatasetBuilder(spark).withIdColumn(ID_ALIAS).withColumn(DataTypes.StringType) + .withRow("patient-1", "2005-02-07T18:28:17+00:00") + .withRow("patient-2", "2005-02-07T18:28:17+00:00") + .withRow("patient-3", "2005-02-07T18:28:17+00:00") + .build()) + ); + + parameters.add(new TestParameters("@2015-02-07T18:28:17+00:00 - 9 months", dateTimeLiteralPath, + QuantityLiteralPath.fromCalendarDurationString("9 months", dateTimeLiteralPath), context, + Operator.getInstance("-"), + new DatasetBuilder(spark).withIdColumn(ID_ALIAS).withColumn(DataTypes.StringType) + .withRow("patient-1", "2014-05-07T18:28:17+00:00") + .withRow("patient-2", "2014-05-07T18:28:17+00:00") + .withRow("patient-3", "2014-05-07T18:28:17+00:00") + .build()) + ); + + parameters.add(new TestParameters("@2015-02-07T18:28:17+00:00 - 30 days", dateTimeLiteralPath, + QuantityLiteralPath.fromCalendarDurationString("30 days", dateTimeLiteralPath), context, + Operator.getInstance("-"), + new DatasetBuilder(spark).withIdColumn(ID_ALIAS).withColumn(DataTypes.StringType) + .withRow("patient-1", "2015-01-08T18:28:17+00:00") + .withRow("patient-2", "2015-01-08T18:28:17+00:00") + .withRow("patient-3", "2015-01-08T18:28:17+00:00") + .build()) + ); + + parameters.add(new TestParameters("@2015-02-07T18:28:17+00:00 - 12 hours", dateTimeLiteralPath, + QuantityLiteralPath.fromCalendarDurationString("12 hours", dateTimeLiteralPath), context, + Operator.getInstance("-"), + new DatasetBuilder(spark).withIdColumn(ID_ALIAS).withColumn(DataTypes.StringType) + .withRow("patient-1", "2015-02-07T06:28:17+00:00") + .withRow("patient-2", "2015-02-07T06:28:17+00:00") + .withRow("patient-3", "2015-02-07T06:28:17+00:00") + .build()) + ); + + parameters.add( + new TestParameters("@2015-02-07T18:28:17+00:00 - 30 minutes", dateTimeLiteralPath, + QuantityLiteralPath.fromCalendarDurationString("30 minutes", dateTimeLiteralPath), + context, + Operator.getInstance("-"), + new DatasetBuilder(spark).withIdColumn(ID_ALIAS).withColumn(DataTypes.StringType) + .withRow("patient-1", "2015-02-07T17:58:17+00:00") + .withRow("patient-2", "2015-02-07T17:58:17+00:00") + .withRow("patient-3", "2015-02-07T17:58:17+00:00") + .build()) + ); + + parameters.add( + new TestParameters("@2015-02-07T18:28:17+00:00 - 10 seconds", dateTimeLiteralPath, + QuantityLiteralPath.fromCalendarDurationString("10 seconds", dateTimeLiteralPath), + context, + Operator.getInstance("-"), + new DatasetBuilder(spark).withIdColumn(ID_ALIAS).withColumn(DataTypes.StringType) + .withRow("patient-1", "2015-02-07T18:28:07+00:00") + .withRow("patient-2", "2015-02-07T18:28:07+00:00") + .withRow("patient-3", "2015-02-07T18:28:07+00:00") + .build()) + ); + + parameters.add( + new TestParameters("@2015-02-07T18:28:17+00:00 - 300 milliseconds", dateTimeLiteralPath, + QuantityLiteralPath.fromCalendarDurationString("300 milliseconds", dateTimeLiteralPath), + context, + Operator.getInstance("-"), + new DatasetBuilder(spark).withIdColumn(ID_ALIAS).withColumn(DataTypes.StringType) + .withRow("patient-1", "2015-02-07T18:28:16+00:00") + .withRow("patient-2", "2015-02-07T18:28:16+00:00") + .withRow("patient-3", "2015-02-07T18:28:16+00:00") + .build()) + ); + + return parameters; + } + + Collection dateLiteralAddition( + final FhirPath dateLiteralPath, final ParserContext context) { + final List parameters = new ArrayList<>(); + parameters.add(new TestParameters("@2015-02-07 + 10 years", dateLiteralPath, + QuantityLiteralPath.fromCalendarDurationString("10 years", dateLiteralPath), context, + Operator.getInstance("+"), + new DatasetBuilder(spark).withIdColumn(ID_ALIAS).withColumn(DataTypes.StringType) + .withRow("patient-1", "2025-02-07") + .withRow("patient-2", "2025-02-07") + .withRow("patient-3", "2025-02-07") + .build()) + ); + + parameters.add(new TestParameters("@2015-02-07 + 9 months", dateLiteralPath, + QuantityLiteralPath.fromCalendarDurationString("9 months", dateLiteralPath), context, + Operator.getInstance("+"), + new DatasetBuilder(spark).withIdColumn(ID_ALIAS).withColumn(DataTypes.StringType) + .withRow("patient-1", "2015-11-07") + .withRow("patient-2", "2015-11-07") + .withRow("patient-3", "2015-11-07") + .build()) + ); + + parameters.add(new TestParameters("@2015-02-07 + 30 days", dateLiteralPath, + QuantityLiteralPath.fromCalendarDurationString("30 days", dateLiteralPath), context, + Operator.getInstance("+"), + new DatasetBuilder(spark).withIdColumn(ID_ALIAS).withColumn(DataTypes.StringType) + .withRow("patient-1", "2015-03-09") + .withRow("patient-2", "2015-03-09") + .withRow("patient-3", "2015-03-09") + .build()) + ); + + return parameters; + } + + Collection dateLiteralSubtraction( + final FhirPath dateLiteralPath, final ParserContext context) { + final List parameters = new ArrayList<>(); + parameters.add(new TestParameters("@2015-02-07 - 10 years", dateLiteralPath, + QuantityLiteralPath.fromCalendarDurationString("10 years", dateLiteralPath), context, + Operator.getInstance("-"), + new DatasetBuilder(spark).withIdColumn(ID_ALIAS).withColumn(DataTypes.StringType) + .withRow("patient-1", "2005-02-07") + .withRow("patient-2", "2005-02-07") + .withRow("patient-3", "2005-02-07") + .build()) + ); + + parameters.add(new TestParameters("@2015-02-07 - 9 months", dateLiteralPath, + QuantityLiteralPath.fromCalendarDurationString("9 months", dateLiteralPath), context, + Operator.getInstance("-"), + new DatasetBuilder(spark).withIdColumn(ID_ALIAS).withColumn(DataTypes.StringType) + .withRow("patient-1", "2014-05-07") + .withRow("patient-2", "2014-05-07") + .withRow("patient-3", "2014-05-07") + .build()) + ); + + parameters.add(new TestParameters("@2015-02-07 - 30 days", dateLiteralPath, + QuantityLiteralPath.fromCalendarDurationString("30 days", dateLiteralPath), context, + Operator.getInstance("-"), + new DatasetBuilder(spark).withIdColumn(ID_ALIAS).withColumn(DataTypes.StringType) + .withRow("patient-1", "2015-01-08") + .withRow("patient-2", "2015-01-08") + .withRow("patient-3", "2015-01-08") + .build()) + ); + + return parameters; + } + + @ParameterizedTest + @MethodSource("parameters") + void test(@Nonnull final TestParameters parameters) { + final OperatorInput input = new OperatorInput(parameters.getContext(), + parameters.getLeft(), parameters.getRight()); + final FhirPath result = parameters.getOperator().invoke(input); + assertThat(result).selectOrderedResult().hasRows(parameters.getExpectedResult()); + } + +} diff --git a/fhir-server/src/test/java/au/csiro/pathling/fhirpath/operator/EqualityOperatorQuantityTest.java b/fhir-server/src/test/java/au/csiro/pathling/fhirpath/operator/EqualityOperatorQuantityTest.java new file mode 100644 index 0000000000..a27630ac5b --- /dev/null +++ b/fhir-server/src/test/java/au/csiro/pathling/fhirpath/operator/EqualityOperatorQuantityTest.java @@ -0,0 +1,541 @@ +/* + * 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.fhirpath.operator; + +import static au.csiro.pathling.test.assertions.Assertions.assertThat; +import static au.csiro.pathling.test.helpers.SparkHelpers.quantityStructType; +import static au.csiro.pathling.test.helpers.SparkHelpers.rowForUcumQuantity; +import static au.csiro.pathling.test.helpers.SparkHelpers.rowFromQuantity; + +import au.csiro.pathling.fhirpath.FhirPath; +import au.csiro.pathling.fhirpath.literal.QuantityLiteralPath; +import au.csiro.pathling.fhirpath.parser.ParserContext; +import au.csiro.pathling.test.builders.DatasetBuilder; +import au.csiro.pathling.test.builders.ElementPathBuilder; +import au.csiro.pathling.test.builders.ParserContextBuilder; +import au.csiro.pathling.test.helpers.TestHelpers; +import ca.uhn.fhir.context.FhirContext; +import java.util.Collections; +import java.util.List; +import org.apache.spark.sql.Dataset; +import org.apache.spark.sql.Row; +import org.apache.spark.sql.RowFactory; +import org.apache.spark.sql.SparkSession; +import org.apache.spark.sql.types.DataTypes; +import org.fhir.ucum.UcumService; +import org.hl7.fhir.r4.model.Enumerations.FHIRDefinedType; +import org.hl7.fhir.r4.model.Quantity; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; + +@SpringBootTest +@Tag("UnitTest") +public class EqualityOperatorQuantityTest { + + @Autowired + SparkSession spark; + + @Autowired + FhirContext fhirContext; + + @Autowired + UcumService ucumService; + + static final String ID_ALIAS = "_abc123"; + + FhirPath left; + FhirPath right; + ParserContext parserContext; + QuantityLiteralPath ucumQuantityLiteral1; + QuantityLiteralPath ucumQuantityLiteral2; + QuantityLiteralPath ucumQuantityLiteral3; + QuantityLiteralPath calendarDurationLiteral1; + QuantityLiteralPath calendarDurationLiteral2; + QuantityLiteralPath calendarDurationLiteral3; + QuantityLiteralPath ucumQuantityLiteralNoUnit; + + @BeforeEach + void setUp() { + final Quantity quantity1 = new Quantity(); + quantity1.setValue(500); + quantity1.setUnit("mg"); + quantity1.setSystem(TestHelpers.UCUM_URL); + quantity1.setCode("mg"); + + final Quantity quantity2 = new Quantity(); + quantity2.setValue(0.5); + quantity2.setUnit("g"); + quantity2.setSystem(TestHelpers.UCUM_URL); + quantity2.setCode("g"); + + final Quantity quantity3 = new Quantity(); + quantity3.setValue(1.8); + quantity3.setUnit("m"); + quantity3.setSystem(TestHelpers.UCUM_URL); + quantity3.setCode("m"); + + final Quantity quantity4 = new Quantity(); + quantity4.setValue(0.5); + quantity4.setUnit("g"); + quantity4.setSystem(TestHelpers.SNOMED_URL); + quantity4.setCode("258682000"); + + final Quantity quantity5 = new Quantity(); + quantity5.setValue(650); + quantity5.setUnit("mg"); + quantity5.setSystem(TestHelpers.UCUM_URL); + quantity5.setCode("mg"); + + final Quantity quantity6 = new Quantity(); + quantity6.setValue(30); + quantity6.setUnit("d"); + quantity6.setSystem(TestHelpers.UCUM_URL); + quantity6.setCode("d"); + + final Quantity quantity7 = new Quantity(); + quantity7.setValue(60); + quantity7.setUnit("s"); + quantity7.setSystem(TestHelpers.UCUM_URL); + quantity7.setCode("s"); + + final Quantity quantity8 = new Quantity(); + quantity8.setValue(1000); + quantity8.setUnit("ms"); + quantity8.setSystem(TestHelpers.UCUM_URL); + quantity8.setCode("ms"); + + final Quantity nonUcumQuantity = new Quantity(); + nonUcumQuantity.setValue(15); + nonUcumQuantity.setUnit("mSv"); + nonUcumQuantity.setSystem(TestHelpers.SNOMED_URL); + nonUcumQuantity.setCode("282250007"); + + final Dataset leftDataset = new DatasetBuilder(spark) + .withIdColumn(ID_ALIAS) + .withStructTypeColumns(quantityStructType()) + .withRow("patient-1", rowFromQuantity(quantity1)) // 500 mg + .withRow("patient-2", rowFromQuantity(quantity1)) // 500 mg + .withRow("patient-3", rowFromQuantity(quantity1)) // 500 mg + .withRow("patient-4", rowFromQuantity(quantity5)) // 650 mg + .withRow("patient-5", null) + .withRow("patient-6", rowFromQuantity(quantity1)) // 500 mg + .withRow("patient-7", rowFromQuantity(quantity6)) // 30 d + .withRow("patient-8", rowFromQuantity(quantity7)) // 60 s + .withRow("patient-9", rowFromQuantity(quantity8)) // 1000 ms + .withRow("patient-a", rowForUcumQuantity("1000", "mmol")) // 1000 mmol + .withRow("patient-b", rowForUcumQuantity("49", "%")) // 49 % + .withRow("patient-c", rowFromQuantity(nonUcumQuantity)) // non-ucum + .buildWithStructValue(); + left = new ElementPathBuilder(spark) + .fhirType(FHIRDefinedType.QUANTITY) + .singular(true) + .dataset(leftDataset) + .idAndValueColumns() + .build(); + + final Dataset rightDataset = new DatasetBuilder(spark) + .withIdColumn(ID_ALIAS) + .withStructTypeColumns(quantityStructType()) + .withRow("patient-1", rowFromQuantity(quantity1)) // 500 mg + .withRow("patient-2", rowFromQuantity(quantity2)) // 0.5 g + .withRow("patient-3", rowFromQuantity(quantity3)) // 1.8 m + .withRow("patient-4", rowFromQuantity(quantity1)) // 500 mg + .withRow("patient-5", rowFromQuantity(quantity1)) // 500 mg + .withRow("patient-6", null) + .withRow("patient-7", rowFromQuantity(quantity6)) // 30 d + .withRow("patient-8", rowFromQuantity(quantity7)) // 60 s + .withRow("patient-9", rowFromQuantity(quantity8)) // 1000 ms + .withRow("patient-a", rowForUcumQuantity("1", "mol")) // 1 mol + .withRow("patient-b", rowForUcumQuantity("0.5", "1")) // 0.5 '1' + .withRow("patient-c", rowForUcumQuantity("1", "%")) // 1 % + .buildWithStructValue(); + right = new ElementPathBuilder(spark) + .fhirType(FHIRDefinedType.QUANTITY) + .singular(true) + .dataset(rightDataset) + .idAndValueColumns() + .build(); + + ucumQuantityLiteral1 = QuantityLiteralPath.fromUcumString("500 'mg'", left, ucumService); + ucumQuantityLiteral2 = QuantityLiteralPath.fromUcumString("0.5 'g'", left, ucumService); + ucumQuantityLiteral3 = QuantityLiteralPath.fromUcumString("1.8 'm'", left, ucumService); + ucumQuantityLiteralNoUnit = QuantityLiteralPath.fromUcumString("0.49 '1'", left, ucumService); + + calendarDurationLiteral1 = QuantityLiteralPath.fromCalendarDurationString("30 days", left); + calendarDurationLiteral2 = QuantityLiteralPath.fromCalendarDurationString("60 seconds", left); + calendarDurationLiteral3 = QuantityLiteralPath.fromCalendarDurationString("1000 milliseconds", + left); + + parserContext = new ParserContextBuilder(spark, fhirContext) + .groupingColumns(Collections.singletonList(left.getIdColumn())) + .build(); + } + + @Test + void equals() { + final OperatorInput input = new OperatorInput(parserContext, left, right); + final Operator equalityOperator = Operator.getInstance("="); + final FhirPath result = equalityOperator.invoke(input); + + assertThat(result).selectOrderedResult().hasRows( + RowFactory.create("patient-1", true), // 500 mg = 500 mg + RowFactory.create("patient-2", true), // 500 mg = 0.5 g + RowFactory.create("patient-3", null), // 500 mg = 1.8 m + RowFactory.create("patient-4", false), // 650 mg = 500 mg + RowFactory.create("patient-5", null), // {} = 500 mg + RowFactory.create("patient-6", null), // 500 mg = {} + RowFactory.create("patient-7", true), // 30 d = 30 d + RowFactory.create("patient-8", true), // 60 s = 60 s + RowFactory.create("patient-9", true), // 1000 ms = 1000 ms + RowFactory.create("patient-a", true), // 1000 mmol = 1 mol + RowFactory.create("patient-b", false), // 49 % = 0.5 '' + RowFactory.create("patient-c", null) // non-ucum = 1 % + ); + } + + @Test + void notEquals() { + final OperatorInput input = new OperatorInput(parserContext, left, right); + final Operator equalityOperator = Operator.getInstance("!="); + final FhirPath result = equalityOperator.invoke(input); + + assertThat(result).selectOrderedResult().hasRows( + RowFactory.create("patient-1", false), // 500 mg != 500 mg + RowFactory.create("patient-2", false), // 500 mg != 0.5 g + RowFactory.create("patient-3", null), // 500 mg != 1.8 m + RowFactory.create("patient-4", true), // 650 mg != 500 mg + RowFactory.create("patient-5", null), // {} != 500 mg + RowFactory.create("patient-6", null), // 500 mg != {} + RowFactory.create("patient-7", false), // 30 d != 30 d + RowFactory.create("patient-8", false), // 60 s != 60 s + RowFactory.create("patient-9", false), // 1000 ms != 1000 ms + RowFactory.create("patient-a", false), // 1000 mmol != 1 mol + RowFactory.create("patient-b", true), // 49 % != 0.5 '' + RowFactory.create("patient-c", null) // non-ucum != 1 % + ); + } + + @Test + void ucumLiteralEquals() { + OperatorInput input = new OperatorInput(parserContext, left, ucumQuantityLiteral1); + final Operator equalityOperator = Operator.getInstance("="); + FhirPath result = equalityOperator.invoke(input); + + assertThat(result).selectOrderedResult().hasRows( + RowFactory.create("patient-1", true), // 500 mg = 500 mg + RowFactory.create("patient-2", true), // 500 mg = 500 mg + RowFactory.create("patient-3", true), // 500 mg = 500 mg + RowFactory.create("patient-4", false), // 650 mg = 500 mg + RowFactory.create("patient-5", null), // {} = 500 mg + RowFactory.create("patient-6", true), // 500 mg = 500 mg + RowFactory.create("patient-7", null), // 30 d = 500 mg + RowFactory.create("patient-8", null), // 60 s = 500 mg + RowFactory.create("patient-9", null), // 1000 ms = 500 mg + RowFactory.create("patient-a", null), // 1000 mmol = 500 mg + RowFactory.create("patient-b", null), // 49 % = 500 mg + RowFactory.create("patient-c", null) // non-ucum = 500 mg + ); + + input = new OperatorInput(parserContext, left, ucumQuantityLiteral2); + result = equalityOperator.invoke(input); + + assertThat(result).selectOrderedResult().hasRows( + RowFactory.create("patient-1", true), // 500 mg = 0.5 mg + RowFactory.create("patient-2", true), // 500 mg = 0.5 mg + RowFactory.create("patient-3", true), // 500 mg = 0.5 mg + RowFactory.create("patient-4", false), // 650 mg = 0.5 mg + RowFactory.create("patient-5", null), // {} = 0.5 mg + RowFactory.create("patient-6", true), // 500 mg = 0.5 mg + RowFactory.create("patient-7", null), // 30 d = 0.5 mg + RowFactory.create("patient-8", null), // 60 s = 0.5 mg + RowFactory.create("patient-9", null), // 1000 ms = 0.5 mg + RowFactory.create("patient-a", null), // 1000 mmol = 0.5 mg + RowFactory.create("patient-b", null), // 49 % = 0.5 mg + RowFactory.create("patient-c", null) // non-ucum = 0.5 mg + ); + + input = new OperatorInput(parserContext, left, ucumQuantityLiteral3); + result = equalityOperator.invoke(input); + + assertThat(result).selectOrderedResult().hasRows( + RowFactory.create("patient-1", null), // 500 mg = 1.8 m + RowFactory.create("patient-2", null), // 500 mg = 1.8 m + RowFactory.create("patient-3", null), // 500 mg = 1.8 m + RowFactory.create("patient-4", null), // 650 mg = 1.8 m + RowFactory.create("patient-5", null), // {} = 1.8 m + RowFactory.create("patient-6", null), // 500 mg = 1.8 m + RowFactory.create("patient-7", null), // 30 d = 1.8 m + RowFactory.create("patient-8", null), // 60 s = 1.8 m + RowFactory.create("patient-9", null), // 1000 ms = 1.8 m + RowFactory.create("patient-a", null), // 1000 mmol = 1.8 m + RowFactory.create("patient-b", null), // 49 % = 1.8 m + RowFactory.create("patient-c", null) // non-ucum = 1.8 m + ); + + input = new OperatorInput(parserContext, left, ucumQuantityLiteralNoUnit); + result = equalityOperator.invoke(input); + + assertThat(result).selectOrderedResult().hasRows( + RowFactory.create("patient-1", null), // 500 mg = 0.49 '1' + RowFactory.create("patient-2", null), // 500 mg = 0.49 '1' + RowFactory.create("patient-3", null), // 500 mg = 0.49 '1' + RowFactory.create("patient-4", null), // 650 mg = 0.49 '1' + RowFactory.create("patient-5", null), // {} = 0.49 '1' + RowFactory.create("patient-6", null), // 500 mg = 0.49 '1 + RowFactory.create("patient-7", null), // 30 d = 0.49 '1' + RowFactory.create("patient-8", null), // 60 s = 0.49 '1' + RowFactory.create("patient-9", null), // 1000 ms = 0.49 '1' + RowFactory.create("patient-a", false), // 1000 mmol = 0.49 '1' + RowFactory.create("patient-b", true), // 49 % = 0.49 '1' + RowFactory.create("patient-c", null) // non-ucum = 0.49 '1' + ); + + input = new OperatorInput(parserContext, ucumQuantityLiteral1, ucumQuantityLiteral1); + result = equalityOperator.invoke(input); + + final Dataset allTrue = new DatasetBuilder(spark) + .withIdColumn() + .withColumn(DataTypes.BooleanType) + .withIdsAndValue(true, + List.of("patient-1", "patient-2", "patient-3", "patient-4", "patient-5", "patient-6", + "patient-7", "patient-8", "patient-9", "patient-a", "patient-b", "patient-c")) + .build(); + assertThat(result).selectOrderedResult().hasRows(allTrue); + } + + @Test + void ucumLiteralNotEquals() { + OperatorInput input = new OperatorInput(parserContext, left, ucumQuantityLiteral1); + final Operator equalityOperator = Operator.getInstance("!="); + FhirPath result = equalityOperator.invoke(input); + + assertThat(result).selectOrderedResult().hasRows( + RowFactory.create("patient-1", false), // 500 mg != 500 mg + RowFactory.create("patient-2", false), // 500 mg != 500 mg + RowFactory.create("patient-3", false), // 500 mg != 500 mg + RowFactory.create("patient-4", true), // 650 mg != 500 mg + RowFactory.create("patient-5", null), // {} != 500 mg + RowFactory.create("patient-6", false), // 500 mg != 500 mg + RowFactory.create("patient-7", null), // 30 d != 500 mg + RowFactory.create("patient-8", null), // 60 s != 500 mg + RowFactory.create("patient-9", null), // 1000 ms != 500 mg + RowFactory.create("patient-a", null), // 1000 mmol != 500 mg + RowFactory.create("patient-b", null), // 49 % != 500 mg + RowFactory.create("patient-c", null) // non-ucum != 500 mg + ); + + input = new OperatorInput(parserContext, left, ucumQuantityLiteral2); + result = equalityOperator.invoke(input); + + assertThat(result).selectOrderedResult().hasRows( + RowFactory.create("patient-1", false), // 500 mg != 0.5 mg + RowFactory.create("patient-2", false), // 500 mg != 0.5 mg + RowFactory.create("patient-3", false), // 500 mg != 0.5 mg + RowFactory.create("patient-4", true), // 650 mg != 0.5 mg + RowFactory.create("patient-5", null), // {} != 0.5 mg + RowFactory.create("patient-6", false), // 500 mg != 0.5 mg + RowFactory.create("patient-7", null), // 30 d != 0.5 mg + RowFactory.create("patient-8", null), // 60 s != 0.5 mg + RowFactory.create("patient-9", null), // 1000 ms != 0.5 mg + RowFactory.create("patient-a", null), // 1000 mmol != 0.5 mg + RowFactory.create("patient-b", null), // 49 % != 0.5 mg + RowFactory.create("patient-c", null) // non-ucum != 0.5 mg + ); + + input = new OperatorInput(parserContext, left, ucumQuantityLiteral3); + result = equalityOperator.invoke(input); + + assertThat(result).selectOrderedResult().hasRows( + RowFactory.create("patient-1", null), // 500 mg != 1.8 m + RowFactory.create("patient-2", null), // 500 mg != 1.8 m + RowFactory.create("patient-3", null), // 500 mg != 1.8 m + RowFactory.create("patient-4", null), // 650 mg != 1.8 m + RowFactory.create("patient-5", null), // {} != 1.8 m + RowFactory.create("patient-6", null), // 500 mg != 1.8 m + RowFactory.create("patient-7", null), // 30 d != 1.8 m + RowFactory.create("patient-8", null), // 60 s != 1.8 m + RowFactory.create("patient-9", null), // 1000 ms != 1.8 m + RowFactory.create("patient-a", null), // 1000 mmol != 1.8 m + RowFactory.create("patient-b", null), // 49 % != 1.8 m + RowFactory.create("patient-c", null) // non-ucum != 1.8 m + ); + + input = new OperatorInput(parserContext, left, ucumQuantityLiteralNoUnit); + result = equalityOperator.invoke(input); + + assertThat(result).selectOrderedResult().hasRows( + RowFactory.create("patient-1", null), // 500 mg != 0.49 '' + RowFactory.create("patient-2", null), // 500 mg != 0.49 '' + RowFactory.create("patient-3", null), // 500 mg != 0.49 '' + RowFactory.create("patient-4", null), // 650 mg != 0.49 '' + RowFactory.create("patient-5", null), // {} != 0.49 '' + RowFactory.create("patient-6", null), // 500 mg != 0.49 '' + RowFactory.create("patient-7", null), // 30 d != 0.49 '' + RowFactory.create("patient-8", null), // 60 s != 0.49 '' + RowFactory.create("patient-9", null), // 1000 ms != 0.49 '' + RowFactory.create("patient-a", true), // 1000 mmol != 0.49 '' + RowFactory.create("patient-b", false), // 49 % != 0.49 '' + RowFactory.create("patient-c", null) // non-ucum != 0.49 '' + ); + + input = new OperatorInput(parserContext, ucumQuantityLiteral1, ucumQuantityLiteral1); + result = equalityOperator.invoke(input); + + final Dataset allFalse = new DatasetBuilder(spark) + .withIdColumn() + .withColumn(DataTypes.BooleanType) + .withIdsAndValue(false, + List.of("patient-1", "patient-2", "patient-3", "patient-4", "patient-5", "patient-6", + "patient-7", "patient-8", "patient-9", "patient-a", "patient-b", "patient-c")) + .build(); + assertThat(result).selectOrderedResult().hasRows(allFalse); + } + + @Test + void calendarLiteralEquals() { + OperatorInput input = new OperatorInput(parserContext, left, calendarDurationLiteral1); + final Operator equalityOperator = Operator.getInstance("="); + FhirPath result = equalityOperator.invoke(input); + + assertThat(result).selectOrderedResult().hasRows( + RowFactory.create("patient-1", null), // 500 mg = 30 days + RowFactory.create("patient-2", null), // 500 mg = 30 days + RowFactory.create("patient-3", null), // 500 mg = 30 days + RowFactory.create("patient-4", null), // 650 mg = 30 days + RowFactory.create("patient-5", null), // {} = 30 days + RowFactory.create("patient-6", null), // 500 mg = 30 days + RowFactory.create("patient-7", null), // 30 d = 30 days + RowFactory.create("patient-8", null), // 60 s = 30 days + RowFactory.create("patient-9", null), // 1000 ms = 30 days + RowFactory.create("patient-a", null), // 1000 mmol = 30 days + RowFactory.create("patient-b", null), // 49 % = 30 days + RowFactory.create("patient-c", null) // non-ucum = 30 days + ); + + input = new OperatorInput(parserContext, left, calendarDurationLiteral2); + result = equalityOperator.invoke(input); + + assertThat(result).selectOrderedResult().hasRows( + RowFactory.create("patient-1", null), // 500 mg = 60 seconds + RowFactory.create("patient-2", null), // 500 mg = 60 seconds + RowFactory.create("patient-3", null), // 500 mg = 60 seconds + RowFactory.create("patient-4", null), // 650 mg = 60 seconds + RowFactory.create("patient-5", null), // {} = 60 seconds + RowFactory.create("patient-6", null), // 500 mg = 60 seconds + RowFactory.create("patient-7", false), // 30 d = 60 seconds + RowFactory.create("patient-8", true), // 60 s = 60 seconds + RowFactory.create("patient-9", false), // 1000 ms = 60 seconds + RowFactory.create("patient-a", null), // 1000 mmol = 60 seconds + RowFactory.create("patient-b", null), // 49 % = 60 seconds + RowFactory.create("patient-c", null) // non-ucum = 60 seconds + ); + + input = new OperatorInput(parserContext, left, calendarDurationLiteral3); + result = equalityOperator.invoke(input); + + assertThat(result).selectOrderedResult().hasRows( + RowFactory.create("patient-1", null), // 500 mg = 1000 milliseconds + RowFactory.create("patient-2", null), // 500 mg = 1000 milliseconds + RowFactory.create("patient-3", null), // 500 mg = 1000 milliseconds + RowFactory.create("patient-4", null), // 650 mg = 1000 milliseconds + RowFactory.create("patient-5", null), // {} = 1000 milliseconds + RowFactory.create("patient-6", null), // 500 mg = 1000 milliseconds + RowFactory.create("patient-7", false), // 30 d = 1000 milliseconds + RowFactory.create("patient-8", false), // 60 s = 1000 milliseconds + RowFactory.create("patient-9", true), // 1000 ms = 1000 milliseconds + RowFactory.create("patient-a", null), // 1000 mmol = 1000 milliseconds + RowFactory.create("patient-b", null), // 49 % = 1000 milliseconds + RowFactory.create("patient-c", null) // non-ucum = 1000 milliseconds + ); + + input = new OperatorInput(parserContext, calendarDurationLiteral2, calendarDurationLiteral2); + result = equalityOperator.invoke(input); + + final Dataset allTrue = new DatasetBuilder(spark) + .withIdColumn() + .withColumn(DataTypes.BooleanType) + .withIdsAndValue(true, + List.of("patient-1", "patient-2", "patient-3", "patient-4", "patient-5", "patient-6", + "patient-7", "patient-8", "patient-9", "patient-a", "patient-b", "patient-c")) + .build(); + assertThat(result).selectOrderedResult().hasRows(allTrue); + } + + @Test + void calendarLiteralNotEquals() { + OperatorInput input = new OperatorInput(parserContext, left, calendarDurationLiteral1); + final Operator equalityOperator = Operator.getInstance("!="); + FhirPath result = equalityOperator.invoke(input); + + assertThat(result).selectOrderedResult().hasRows( + RowFactory.create("patient-1", null), // 500 mg != 30 days + RowFactory.create("patient-2", null), // 500 mg != 30 days + RowFactory.create("patient-3", null), // 500 mg != 30 days + RowFactory.create("patient-4", null), // 650 mg != 30 days + RowFactory.create("patient-5", null), // {} != 30 days + RowFactory.create("patient-6", null), // 500 mg != 30 days + RowFactory.create("patient-7", null), // 30 d != 30 days + RowFactory.create("patient-8", null), // 60 s != 30 days + RowFactory.create("patient-9", null), // 1000 ms != 30 days + RowFactory.create("patient-a", null), // 1000 mmol != 30 days + RowFactory.create("patient-b", null), // 49 % != 30 days + RowFactory.create("patient-c", null) // non-ucum != 30 days + ); + + input = new OperatorInput(parserContext, left, calendarDurationLiteral2); + result = equalityOperator.invoke(input); + + assertThat(result).selectOrderedResult().hasRows( + RowFactory.create("patient-1", null), // 500 mg != 60 s + RowFactory.create("patient-2", null), // 500 mg != 60 s + RowFactory.create("patient-3", null), // 500 mg != 60 s + RowFactory.create("patient-4", null), // 650 mg != 60 s + RowFactory.create("patient-5", null), // {} != 60 s + RowFactory.create("patient-6", null), // 500 mg != 60 s + RowFactory.create("patient-7", true), // 30 d != 60 s + RowFactory.create("patient-8", false), // 60 s != 60 s + RowFactory.create("patient-9", true), // 1000 ms != 60 s + RowFactory.create("patient-a", null), // 1000 mmol != 60 seconds + RowFactory.create("patient-b", null), // 49 % != 60 seconds + RowFactory.create("patient-c", null) // non-ucum != 60 seconds + ); + + input = new OperatorInput(parserContext, left, calendarDurationLiteral3); + result = equalityOperator.invoke(input); + + assertThat(result).selectOrderedResult().hasRows( + RowFactory.create("patient-1", null), // 500 mg != 1000 ms + RowFactory.create("patient-2", null), // 500 mg != 1000 ms + RowFactory.create("patient-3", null), // 500 mg != 1000 ms + RowFactory.create("patient-4", null), // 650 mg != 1000 ms + RowFactory.create("patient-5", null), // {} != 1000 ms + RowFactory.create("patient-6", null), // 500 mg != 1000 ms + RowFactory.create("patient-7", true), // 30 d != 1000 ms + RowFactory.create("patient-8", true), // 60 s != 1000 ms + RowFactory.create("patient-9", false), // 1000 ms != 1000 ms + RowFactory.create("patient-a", null), // 1000 mmol != 1000 milliseconds + RowFactory.create("patient-b", null), // 49 % != 1000 milliseconds + RowFactory.create("patient-c", null) // non-ucum != 1000 milliseconds + ); + + input = new OperatorInput(parserContext, calendarDurationLiteral2, calendarDurationLiteral2); + result = equalityOperator.invoke(input); + + final Dataset allFalse = new DatasetBuilder(spark) + .withIdColumn() + .withColumn(DataTypes.BooleanType) + .withIdsAndValue(false, + List.of("patient-1", "patient-2", "patient-3", "patient-4", "patient-5", "patient-6", + "patient-7", "patient-8", "patient-9", "patient-a", "patient-b", "patient-c")) + .build(); + assertThat(result).selectOrderedResult().hasRows(allFalse); + } + +} diff --git a/fhir-server/src/test/java/au/csiro/pathling/fhirpath/operator/MathOperatorQuantityTest.java b/fhir-server/src/test/java/au/csiro/pathling/fhirpath/operator/MathOperatorQuantityTest.java new file mode 100644 index 0000000000..f8cb31971c --- /dev/null +++ b/fhir-server/src/test/java/au/csiro/pathling/fhirpath/operator/MathOperatorQuantityTest.java @@ -0,0 +1,230 @@ +/* + * 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.fhirpath.operator; + +import static au.csiro.pathling.test.assertions.Assertions.assertThat; +import static au.csiro.pathling.test.helpers.SparkHelpers.quantityStructType; +import static au.csiro.pathling.test.helpers.SparkHelpers.rowForUcumQuantity; +import static au.csiro.pathling.test.helpers.SparkHelpers.rowFromQuantity; + +import au.csiro.pathling.fhirpath.FhirPath; +import au.csiro.pathling.fhirpath.literal.QuantityLiteralPath; +import au.csiro.pathling.fhirpath.parser.ParserContext; +import au.csiro.pathling.test.builders.DatasetBuilder; +import au.csiro.pathling.test.builders.ElementPathBuilder; +import au.csiro.pathling.test.builders.ParserContextBuilder; +import au.csiro.pathling.test.helpers.TestHelpers; +import ca.uhn.fhir.context.FhirContext; +import java.math.BigDecimal; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.List; +import java.util.stream.Stream; +import javax.annotation.Nonnull; +import lombok.Value; +import org.apache.spark.sql.Dataset; +import org.apache.spark.sql.Row; +import org.apache.spark.sql.SparkSession; +import org.fhir.ucum.UcumService; +import org.hl7.fhir.r4.model.Enumerations.FHIRDefinedType; +import org.hl7.fhir.r4.model.Quantity; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.api.TestInstance.Lifecycle; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; + +@SpringBootTest +@TestInstance(Lifecycle.PER_CLASS) +@Tag("UnitTest") +public class MathOperatorQuantityTest { + + @Autowired + SparkSession spark; + + @Autowired + FhirContext fhirContext; + + @Autowired + UcumService ucumService; + + static final List OPERATORS = List.of("+", "-", "*", "/"); + static final String ID_ALIAS = "_abc123"; + + @Value + static class TestParameters { + + @Nonnull + String name; + + @Nonnull + FhirPath left; + + @Nonnull + FhirPath right; + + @Nonnull + ParserContext context; + + @Nonnull + Operator operator; + + @Nonnull + Dataset expectedResult; + + @Override + public String toString() { + return name; + } + + } + + @Nonnull + Stream parameters() { + final Collection parameters = new ArrayList<>(); + for (final String operator : OPERATORS) { + final String name = "Quantity " + operator + " Quantity"; + final FhirPath left = buildQuantityExpression(true); + final FhirPath right = buildQuantityExpression(false); + final ParserContext context = new ParserContextBuilder(spark, fhirContext) + .groupingColumns(Collections.singletonList(left.getIdColumn())) + .build(); + parameters.add(new TestParameters(name, left, right, context, Operator.getInstance(operator), + expectedResult(operator))); + } + return parameters.stream(); + } + + Dataset expectedResult(@Nonnull final String operator) { + final Row result1; + final Row result2; + + switch (operator) { + case "+": + result1 = rowForUcumQuantity(new BigDecimal("1650.0"), "m"); + result2 = null; + break; + case "-": + result1 = rowForUcumQuantity(new BigDecimal("-1350.0"), "m"); + result2 = null; + break; + case "*": + result1 = null; + result2 = rowForUcumQuantity("1000.0", "g"); + break; + case "/": + result1 = rowForUcumQuantity(new BigDecimal("0.1"), "1"); + result2 = rowForUcumQuantity("4000", "g"); + break; + default: + result1 = null; + result2 = null; + } + return new DatasetBuilder(spark) + .withIdColumn(ID_ALIAS) + .withStructTypeColumns(quantityStructType()) + .withRow("patient-1", result1) + .withRow("patient-2", result2) + .withRow("patient-3", null) + .withRow("patient-4", null) + .withRow("patient-5", null) + .withRow("patient-6", null) + .withRow("patient-7", null) + .buildWithStructValue(); + } + + @Nonnull + FhirPath buildQuantityExpression(final boolean leftOperand) { + final Quantity nonUcumQuantity = new Quantity(); + nonUcumQuantity.setValue(15); + nonUcumQuantity.setUnit("mSv"); + nonUcumQuantity.setSystem(TestHelpers.SNOMED_URL); + nonUcumQuantity.setCode("282250007"); + + final Dataset dataset = new DatasetBuilder(spark) + .withIdColumn(ID_ALIAS) + .withStructTypeColumns(quantityStructType()) + .withRow("patient-1", leftOperand + ? rowForUcumQuantity(new BigDecimal("150.0"), "m") + : rowForUcumQuantity(new BigDecimal("1.5"), "km")) + .withRow("patient-2", leftOperand + ? rowForUcumQuantity(new BigDecimal("2.0"), "kg") + : rowForUcumQuantity(new BigDecimal("0.5"), "1")) + .withRow("patient-3", leftOperand + ? rowForUcumQuantity(new BigDecimal("7.7"), "mSv") + : rowForUcumQuantity(new BigDecimal("1.5"), "h")) + // Not comparable + .withRow("patient-4", leftOperand + ? rowForUcumQuantity(new BigDecimal("7.7"), "mSv") + : rowFromQuantity(nonUcumQuantity)) + // Not comparable + .withRow("patient-5", leftOperand + ? null + : rowForUcumQuantity(new BigDecimal("1.5"), "h")) + .withRow("patient-6", leftOperand + ? rowForUcumQuantity(new BigDecimal("7.7"), "mSv") + : null) + .withRow("patient-7", null) + .buildWithStructValue(); + return new ElementPathBuilder(spark) + .fhirType(FHIRDefinedType.QUANTITY) + .dataset(dataset) + .idAndValueColumns() + .singular(true) + .build(); + } + + @ParameterizedTest + @MethodSource("parameters") + void test(@Nonnull final TestParameters parameters) { + final OperatorInput input = new OperatorInput(parameters.getContext(), + parameters.getLeft(), parameters.getRight()); + final FhirPath result = parameters.getOperator().invoke(input); + assertThat(result).selectOrderedResult().hasRows(parameters.getExpectedResult()); + } + + /* + * This test requires a very high precision decimal representation, due to these units being + * canonicalized by UCUM to "reciprocal cubic meters". + * See: https://www.wolframalpha.com/input?i=3+mmol%2FL+in+m%5E-3 + */ + @Test + void volumeArithmetic() { + final Dataset rightDataset = new DatasetBuilder(spark) + .withIdColumn(ID_ALIAS) + .withStructTypeColumns(quantityStructType()) + .withRow("patient-1", rowForUcumQuantity(new BigDecimal("1.0"), "mmol/L")) + .buildWithStructValue(); + final FhirPath right = new ElementPathBuilder(spark) + .expression("valueQuantity") + .fhirType(FHIRDefinedType.QUANTITY) + .singular(true) + .dataset(rightDataset) + .idAndValueColumns() + .build(); + final FhirPath left = QuantityLiteralPath.fromUcumString("1.0 'mmol/L'", right, + ucumService); + final ParserContext context = new ParserContextBuilder(spark, fhirContext) + .groupingColumns(Collections.singletonList(left.getIdColumn())) + .build(); + final OperatorInput input = new OperatorInput(context, left, right); + final FhirPath result = Operator.getInstance("+").invoke(input); + + final Dataset expectedDataset = new DatasetBuilder(spark) + .withIdColumn() + .withStructTypeColumns(quantityStructType()) + .withRow("patient-1", + rowForUcumQuantity(new BigDecimal("1204427340000000000000000"), "m-3")) + .buildWithStructValue(); + assertThat(result).selectOrderedResult().hasRows(expectedDataset); + } + +} diff --git a/fhir-server/src/test/java/au/csiro/pathling/fhirpath/operator/MathOperatorValidationTest.java b/fhir-server/src/test/java/au/csiro/pathling/fhirpath/operator/MathOperatorValidationTest.java index d56b72e47b..63b0aa7f23 100644 --- a/fhir-server/src/test/java/au/csiro/pathling/fhirpath/operator/MathOperatorValidationTest.java +++ b/fhir-server/src/test/java/au/csiro/pathling/fhirpath/operator/MathOperatorValidationTest.java @@ -105,4 +105,35 @@ void operandIsNotSingular() { reversedError.getMessage()); } + @Test + void operandsAreNotComparable() { + final ElementPath left = new ElementPathBuilder(spark) + .fhirType(FHIRDefinedType.INTEGER) + .singular(true) + .expression("foo") + .build(); + final ElementPath right = new ElementPathBuilder(spark) + .fhirType(FHIRDefinedType.QUANTITY) + .singular(true) + .expression("bar") + .build(); + + final OperatorInput input = new OperatorInput(parserContext, left, right); + final Operator mathOperator = Operator.getInstance("+"); + final InvalidUserInputError error = assertThrows( + InvalidUserInputError.class, + () -> mathOperator.invoke(input)); + assertEquals("Left and right operands are not comparable: foo + bar", + error.getMessage()); + + // Now test the right operand. + final OperatorInput reversedInput = new OperatorInput(parserContext, right, left); + final InvalidUserInputError reversedError = assertThrows( + InvalidUserInputError.class, + () -> mathOperator.invoke(reversedInput)); + assertEquals( + "Left and right operands are not comparable: bar + foo", + reversedError.getMessage()); + } + } diff --git a/fhir-server/src/test/java/au/csiro/pathling/fhirpath/operator/QuantityOperatorsPrecisionTest.java b/fhir-server/src/test/java/au/csiro/pathling/fhirpath/operator/QuantityOperatorsPrecisionTest.java new file mode 100644 index 0000000000..5465b3bcb1 --- /dev/null +++ b/fhir-server/src/test/java/au/csiro/pathling/fhirpath/operator/QuantityOperatorsPrecisionTest.java @@ -0,0 +1,224 @@ +/* + * 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.fhirpath.operator; + +import au.csiro.pathling.fhirpath.FhirPath; +import au.csiro.pathling.fhirpath.element.ElementPath; +import au.csiro.pathling.fhirpath.literal.QuantityLiteralPath; +import au.csiro.pathling.fhirpath.parser.ParserContext; +import au.csiro.pathling.test.builders.DatasetBuilder; +import au.csiro.pathling.test.builders.ElementPathBuilder; +import au.csiro.pathling.test.builders.ParserContextBuilder; +import au.csiro.pathling.test.helpers.TestHelpers; +import ca.uhn.fhir.context.FhirContext; +import com.google.common.collect.ImmutableSet; +import org.apache.spark.sql.Dataset; +import org.apache.spark.sql.Row; +import org.apache.spark.sql.RowFactory; +import org.apache.spark.sql.SparkSession; +import org.codehaus.jettison.badgerfish.BadgerFishXMLInputFactory; +import org.fhir.ucum.Prefix; +import org.fhir.ucum.UcumService; +import org.hl7.fhir.r4.model.Enumerations; +import org.hl7.fhir.r4.model.Enumerations.FHIRDefinedType; +import org.hl7.fhir.r4.model.Quantity; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; +import javax.annotation.Nonnull; +import java.math.BigDecimal; +import java.util.Collections; +import java.util.List; +import java.util.Set; +import java.util.stream.Collectors; + +import static au.csiro.pathling.test.assertions.Assertions.assertThat; +import static au.csiro.pathling.test.helpers.SparkHelpers.quantityStructType; +import static au.csiro.pathling.test.helpers.SparkHelpers.rowForUcumQuantity; +import static au.csiro.pathling.test.helpers.SparkHelpers.rowFromQuantity; + +@SpringBootTest +@Tag("UnitTest") +public class QuantityOperatorsPrecisionTest { + + @Autowired + SparkSession spark; + + @Autowired + FhirContext fhirContext; + + @Autowired + UcumService ucumService; + + static final String ID_ALIAS = "_abc123"; + + // Reasonable decimal with units assume above the value of 9999 we would use the next prefix up + // (if available) + + static final String REASONABLE_DECIMAL_01 = createSpanningDecimal(9, 3, 1, + 6).toString(); // 9000.000001 + static final String REASONABLE_DECIMAL_02 = createSpanningDecimal(9, 3, 2, + 6).toString(); // 9000.000002 + + // for Decimal(32,6) + static final String FULL_DECIMAL_01 = createSpanningDecimal(9, 26, 1, + 6).toString(); // 9e26 + 0.00001 + static final String FULL_DECIMAL_02 = createSpanningDecimal(9, 26, 2, + 6).toString(); // 9e26 + 0.00002 + + // These units (prefixes) results in overflow for largest supported decimals (e.g. 9e26 'Tm') + static final Set UNSUPPORTED_FULL_DECIMAL_UNITS = ImmutableSet.of("Ym", "Zm", "Em", "Pm", + "Tm"); + + // These mol prefixes results in overflow for reasonable decimals (e.g. 9e3 'Tmol') + static final Set UNSUPPORTED_RESONABLE_DECIMAL_MOL_UNITS = ImmutableSet.of("Ymol", "Zmol", + "Emol", "Pmol", "Tmol"); + + @BeforeEach + void setUp() { + } + + + @Nonnull + private static String unitToRowId(@Nonnull final String unit) { + return "unit-" + unit; + } + + @Nonnull + private ElementPath buildQuantityPathForUnits(@Nonnull final String value, List units) { + DatasetBuilder datasetBuilder = new DatasetBuilder(spark) + .withIdColumn(ID_ALIAS) + .withStructTypeColumns(quantityStructType()); + for (String unit : units) { + datasetBuilder = datasetBuilder.withRow(unitToRowId(unit), rowForUcumQuantity(value, unit)); + } + final Dataset dataset = datasetBuilder.buildWithStructValue(); + return new ElementPathBuilder(spark) + .fhirType(FHIRDefinedType.QUANTITY) + .singular(true) + .dataset(dataset) + .idAndValueColumns() + .build(); + } + + @Nonnull + private List getAllPrefixedUnits(@Nonnull final String baseUnit) { + return ucumService.getModel().getPrefixes().stream() + .map(Prefix::getCode) + .filter(p -> p.length() == 1) // filter out Ki, Gi etc + .map(p -> p + baseUnit) + .collect(Collectors.toUnmodifiableList()); + } + + @Nonnull + private static BigDecimal createSpanningDecimal(int leftValue, int leftScale, int rightValue, + int rightScale) { + return new BigDecimal(leftValue).movePointRight(leftScale) + .add(new BigDecimal(rightValue).movePointLeft(rightScale)); + } + + @Nonnull + private static List createResult(@Nonnull final List unitRange, boolean result) { + return createResult(unitRange, result, Collections.emptySet()); + } + + @Nonnull + private static List createResult(@Nonnull final List unitRange, boolean result, + @Nonnull final Set outOfRangeUnits) { + return unitRange.stream().map( + unit -> + RowFactory.create(unitToRowId(unit), outOfRangeUnits.contains(unit) + ? null + : result)).collect(Collectors.toList()); + } + + + @Nonnull + private FhirPath callOperator(@Nonnull final ElementPath left, @Nonnull final String operator, + @Nonnull final ElementPath right) { + final ParserContext parserContext = new ParserContextBuilder(spark, fhirContext) + .groupingColumns(Collections.singletonList(left.getIdColumn())) + .build(); + + final OperatorInput input = new OperatorInput(parserContext, left, right); + final Operator equalityOperator = Operator.getInstance(operator); + return equalityOperator.invoke(input); + } + + @Test + void equalityPrecisionForReasonableDecimals() { + final List unitRange = getAllPrefixedUnits("m"); + final ElementPath left = buildQuantityPathForUnits(REASONABLE_DECIMAL_01, unitRange); + final ElementPath right = buildQuantityPathForUnits(REASONABLE_DECIMAL_01, unitRange); + final FhirPath result = callOperator(left, "=", right); + assertThat(result).selectResult().hasRows(createResult(unitRange, true)); + } + + + @Test + void nonEqualityPrecisionForReasonableDecimals() { + final List unitRange = getAllPrefixedUnits("m"); + final ElementPath left = buildQuantityPathForUnits(REASONABLE_DECIMAL_01, unitRange); + final ElementPath right = buildQuantityPathForUnits(REASONABLE_DECIMAL_02, unitRange); + final FhirPath result = callOperator(left, "!=", right); + assertThat(result).selectResult().hasRows(createResult(unitRange, true)); + } + + + @Test + void comparisonPrecisionForReasonableDecimals() { + final List unitRange = getAllPrefixedUnits("m"); + final ElementPath left = buildQuantityPathForUnits(REASONABLE_DECIMAL_01, unitRange); + final ElementPath right = buildQuantityPathForUnits(REASONABLE_DECIMAL_02, unitRange); + final FhirPath result = callOperator(left, "<", right); + assertThat(result).selectResult().hasRows(createResult(unitRange, true)); + } + + + @Test + void equalityPrecisionForFullDecimals() { + final List unitRange = getAllPrefixedUnits("m"); + final ElementPath left = buildQuantityPathForUnits(FULL_DECIMAL_01, unitRange); + final ElementPath right = buildQuantityPathForUnits(FULL_DECIMAL_01, unitRange); + final FhirPath result = callOperator(left, "=", right); + assertThat(result).selectResult() + .hasRows(createResult(unitRange, true, UNSUPPORTED_FULL_DECIMAL_UNITS)); + } + + @Test + void nonEqualityPrecisionForFullDecimals() { + final List unitRange = getAllPrefixedUnits("m"); + final ElementPath left = buildQuantityPathForUnits(FULL_DECIMAL_01, unitRange); + final ElementPath right = buildQuantityPathForUnits(FULL_DECIMAL_02, unitRange); + final FhirPath result = callOperator(left, "!=", right); + assertThat(result).selectResult() + .hasRows(createResult(unitRange, true, UNSUPPORTED_FULL_DECIMAL_UNITS)); + } + + @Test + void comparisonPrecisionForFullDecimals() { + final List unitRange = getAllPrefixedUnits("m"); + final ElementPath left = buildQuantityPathForUnits(FULL_DECIMAL_01, unitRange); + final ElementPath right = buildQuantityPathForUnits(FULL_DECIMAL_02, unitRange); + final FhirPath result = callOperator(left, "<", right); + assertThat(result).selectResult() + .hasRows(createResult(unitRange, true, UNSUPPORTED_FULL_DECIMAL_UNITS)); + } + + @Test + void equalityPrecisionForReasonableDecimalsWithMols() { + final List unitRange = getAllPrefixedUnits("mol"); + final ElementPath left = buildQuantityPathForUnits(REASONABLE_DECIMAL_01, unitRange); + final ElementPath right = buildQuantityPathForUnits(REASONABLE_DECIMAL_01, unitRange); + final FhirPath result = callOperator(left, "=", right); + assertThat(result).selectResult() + .hasRows(createResult(unitRange, true, UNSUPPORTED_RESONABLE_DECIMAL_MOL_UNITS)); + } + +} diff --git a/fhir-server/src/test/java/au/csiro/pathling/fhirpath/parser/AbstractParserTest.java b/fhir-server/src/test/java/au/csiro/pathling/fhirpath/parser/AbstractParserTest.java index 8ebed68c26..df7ed58a07 100644 --- a/fhir-server/src/test/java/au/csiro/pathling/fhirpath/parser/AbstractParserTest.java +++ b/fhir-server/src/test/java/au/csiro/pathling/fhirpath/parser/AbstractParserTest.java @@ -9,9 +9,11 @@ import static au.csiro.pathling.test.assertions.Assertions.assertThat; import static org.mockito.Mockito.when; +import au.csiro.pathling.encoders.FhirEncoders; import au.csiro.pathling.fhir.TerminologyServiceFactory; import au.csiro.pathling.fhirpath.ResourcePath; import au.csiro.pathling.io.Database; +import au.csiro.pathling.terminology.TerminologyService; import au.csiro.pathling.test.SharedMocks; import au.csiro.pathling.test.TimingExtension; import au.csiro.pathling.test.assertions.FhirPathAssertion; @@ -42,6 +44,12 @@ public class AbstractParserTest { @Autowired FhirContext fhirContext; + @Autowired + TerminologyService terminologyService; + + @Autowired + FhirEncoders fhirEncoders; + @Autowired TerminologyServiceFactory terminologyServiceFactory; @@ -93,4 +101,9 @@ protected FhirPathAssertion assertThatResultOf(@Nonnull final ResourceType resou return assertThat(resourceParser.parse(expression)); } + @SuppressWarnings("SameParameterValue") + FhirPathAssertion assertThatResultOf(final String expression) { + return assertThat(parser.parse(expression)); + } + } diff --git a/fhir-server/src/test/java/au/csiro/pathling/fhirpath/parser/DateTimeArithmeticParserTest.java b/fhir-server/src/test/java/au/csiro/pathling/fhirpath/parser/DateTimeArithmeticParserTest.java new file mode 100644 index 0000000000..60b8c8257e --- /dev/null +++ b/fhir-server/src/test/java/au/csiro/pathling/fhirpath/parser/DateTimeArithmeticParserTest.java @@ -0,0 +1,62 @@ +/* + * 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.fhirpath.parser; + +import static au.csiro.pathling.test.helpers.TestHelpers.mockEmptyResource; + +import au.csiro.pathling.fhirpath.ResourcePath; +import au.csiro.pathling.fhirpath.element.BooleanPath; +import au.csiro.pathling.test.builders.ParserContextBuilder; +import java.util.Collections; +import org.hl7.fhir.r4.model.Enumerations.ResourceType; +import org.junit.jupiter.api.Test; + +public class DateTimeArithmeticParserTest extends AbstractParserTest { + + @Test + void lengthOfEncounter() { + final ResourcePath subjectResource = ResourcePath + .build(fhirContext, database, ResourceType.ENCOUNTER, ResourceType.ENCOUNTER.toCode(), + true); + final ParserContext parserContext = new ParserContextBuilder(spark, fhirContext) + .terminologyClientFactory(terminologyServiceFactory) + .database(database) + .inputContext(subjectResource) + .groupingColumns(Collections.singletonList(subjectResource.getIdColumn())) + .build(); + parser = new Parser(parserContext); + + mockEmptyResource(database, spark, fhirEncoders, ResourceType.GROUP); + + assertThatResultOf("(period.start + 20 minutes) > period.end") + .isElementPath(BooleanPath.class) + .selectResult() + .hasRows(spark, "responses/ParserTest/lengthOfEncounter.csv"); + } + + @Test + void ageAtTimeOfEncounter() { + final ResourcePath subjectResource = ResourcePath + .build(fhirContext, database, ResourceType.ENCOUNTER, ResourceType.ENCOUNTER.toCode(), + true); + final ParserContext parserContext = new ParserContextBuilder(spark, fhirContext) + .terminologyClientFactory(terminologyServiceFactory) + .database(database) + .inputContext(subjectResource) + .groupingColumns(Collections.singletonList(subjectResource.getIdColumn())) + .build(); + parser = new Parser(parserContext); + + mockEmptyResource(database, spark, fhirEncoders, ResourceType.GROUP); + + assertThatResultOf("period.start > (subject.resolve().ofType(Patient).birthDate + 60 years)") + .isElementPath(BooleanPath.class) + .selectResult() + .hasRows(spark, "responses/ParserTest/ageAtTimeOfEncounter.csv"); + } + +} diff --git a/fhir-server/src/test/java/au/csiro/pathling/fhirpath/parser/ParserTest.java b/fhir-server/src/test/java/au/csiro/pathling/fhirpath/parser/ParserTest.java index 65d4882cef..e313c1a596 100644 --- a/fhir-server/src/test/java/au/csiro/pathling/fhirpath/parser/ParserTest.java +++ b/fhir-server/src/test/java/au/csiro/pathling/fhirpath/parser/ParserTest.java @@ -6,7 +6,6 @@ package au.csiro.pathling.fhirpath.parser; -import static au.csiro.pathling.test.assertions.Assertions.assertThat; import static au.csiro.pathling.test.fixtures.PatientListBuilder.PATIENT_ID_121503c8; import static au.csiro.pathling.test.fixtures.PatientListBuilder.PATIENT_ID_2b36c1e2; import static au.csiro.pathling.test.fixtures.PatientListBuilder.PATIENT_ID_7001ad9c; @@ -25,7 +24,6 @@ import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.when; -import au.csiro.pathling.encoders.FhirEncoders; import au.csiro.pathling.errors.InvalidUserInputError; import au.csiro.pathling.fhirpath.ResourcePath; import au.csiro.pathling.fhirpath.element.BooleanPath; @@ -40,37 +38,24 @@ import au.csiro.pathling.fhirpath.literal.TimeLiteralPath; import au.csiro.pathling.terminology.ConceptTranslator; import au.csiro.pathling.terminology.Relation; -import au.csiro.pathling.terminology.TerminologyService; -import au.csiro.pathling.test.assertions.FhirPathAssertion; import au.csiro.pathling.test.builders.DatasetBuilder; import au.csiro.pathling.test.builders.ParserContextBuilder; import au.csiro.pathling.test.fixtures.ConceptTranslatorBuilder; import au.csiro.pathling.test.fixtures.RelationBuilder; import au.csiro.pathling.test.helpers.TerminologyHelpers; -import java.sql.Date; import java.util.Collections; +import javax.annotation.Nonnull; import org.apache.spark.sql.types.DataTypes; import org.hl7.fhir.r4.model.Coding; import org.hl7.fhir.r4.model.Enumerations.ResourceType; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; -import org.springframework.beans.factory.annotation.Autowired; /** * @author Piotr Szul */ public class ParserTest extends AbstractParserTest { - - @Autowired - TerminologyService terminologyService; - - @Autowired - FhirEncoders fhirEncoders; - - FhirPathAssertion assertThatResultOf(final String expression) { - return assertThat(parser.parse(expression)); - } - + @SuppressWarnings("SameParameterValue") private T assertThrows(final Class errorType, final String expression) { return Assertions.assertThrows(errorType, () -> parser.parse(expression)); @@ -126,32 +111,80 @@ void testCodingOperations() { @Test void testDateTimeLiterals() { - // Full DateTime. - assertThatResultOf("@2015-02-04T14:34:28Z") + // Milliseconds precision. + assertThatResultOf("@2015-02-04T14:34:28.350Z") + .isLiteralPath(DateTimeLiteralPath.class) + .hasExpression("@2015-02-04T14:34:28.350Z") + .has("2015-02-04T14:34:28.350Z", + dateTime -> dateTime.getValue().dateTimeValue().getValueAsString()); + + // Milliseconds precision, no timezone. + assertThatResultOf("@2015-02-04T14:34:28.350") + .isLiteralPath(DateTimeLiteralPath.class) + .hasExpression("@2015-02-04T14:34:28.350") + .has("2015-02-04T14:34:28.350", + dateTime -> dateTime.getValue().dateTimeValue().getValueAsString()) + .has(null, dateTime -> dateTime.getValue().dateTimeValue().getTimeZone()); + + // Seconds precision. + assertThatResultOf("@2015-02-04T14:34:28-05:00") + .isLiteralPath(DateTimeLiteralPath.class) + .hasExpression("@2015-02-04T14:34:28-05:00") + .has("2015-02-04T14:34:28-05:00", + dateTime -> dateTime.getValue().dateTimeValue().getValueAsString()); + + // Seconds precision, no timezone. + assertThatResultOf("@2015-02-04T14:34:28") .isLiteralPath(DateTimeLiteralPath.class) - .hasExpression("@2015-02-04T14:34:28Z") - .hasJavaValue(new Date(1423060468000L)); + .hasExpression("@2015-02-04T14:34:28") + .has("2015-02-04T14:34:28", + dateTime -> dateTime.getValue().dateTimeValue().getValueAsString()) + .has(null, dateTime -> dateTime.getValue().dateTimeValue().getTimeZone()); + } - // Date with no time component. + @Test + void testDateLiterals() { + // Year, month and day. assertThatResultOf("@2015-02-04") .isLiteralPath(DateLiteralPath.class) .hasExpression("@2015-02-04") - .hasJavaValue(new Date(1423008000000L)); + .has("2015-02-04", date -> date.getValue().castToDate(date.getValue()).getValueAsString()) + .has(null, date -> date.getValue().castToDate(date.getValue()).getTimeZone()); + + // Year and month. + assertThatResultOf("@2015-02") + .isLiteralPath(DateLiteralPath.class) + .hasExpression("@2015-02") + .has("2015-02", date -> date.getValue().castToDate(date.getValue()).getValueAsString()) + .has(null, date -> date.getValue().castToDate(date.getValue()).getTimeZone()); + + // Year only. + assertThatResultOf("@2015") + .isLiteralPath(DateLiteralPath.class) + .hasExpression("@2015") + .has("2015", date -> date.getValue().castToDate(date.getValue()).getValueAsString()) + .has(null, date -> date.getValue().castToDate(date.getValue()).getTimeZone()); } @Test void testTimeLiterals() { - // Full Time. + // Hours, minutes and seconds. assertThatResultOf("@T14:34:28") .isLiteralPath(TimeLiteralPath.class) .hasExpression("@T14:34:28") - .hasJavaValue("14:34:28"); + .has("14:34:28", time -> time.getValue().castToTime(time.getValue()).getValueAsString()); + + // Hours and minutes. + assertThatResultOf("@T14:34") + .isLiteralPath(TimeLiteralPath.class) + .hasExpression("@T14:34") + .has("14:34", time -> time.getValue().castToTime(time.getValue()).getValueAsString()); // Hour only. assertThatResultOf("@T14") .isLiteralPath(TimeLiteralPath.class) .hasExpression("@T14") - .hasJavaValue("14"); + .has("14", time -> time.getValue().castToTime(time.getValue()).getValueAsString()); } @Test @@ -647,18 +680,7 @@ void testTraversalIntoMissingOpenType() { @Test void testReverseResolveFollowingMonomorphicResolve() { - final ResourcePath subjectResource = ResourcePath - .build(fhirContext, database, ResourceType.ENCOUNTER, ResourceType.ENCOUNTER.toCode(), - true); - - final ParserContext parserContext = new ParserContextBuilder(spark, fhirContext) - .terminologyClientFactory(terminologyServiceFactory) - .database(database) - .inputContext(subjectResource) - .groupingColumns(Collections.singletonList(subjectResource.getIdColumn())) - .build(); - parser = new Parser(parserContext); - + setSubjectResource(ResourceType.ENCOUNTER); assertThatResultOf( "serviceProvider.resolve().reverseResolve(Encounter.serviceProvider).id") .isElementPath(StringPath.class) @@ -668,17 +690,7 @@ void testReverseResolveFollowingMonomorphicResolve() { @Test void testReverseResolveFollowingPolymorphicResolve() { - final ResourcePath subjectResource = ResourcePath - .build(fhirContext, database, ResourceType.ENCOUNTER, ResourceType.ENCOUNTER.toCode(), - true); - - final ParserContext parserContext = new ParserContextBuilder(spark, fhirContext) - .terminologyClientFactory(terminologyServiceFactory) - .database(database) - .inputContext(subjectResource) - .groupingColumns(Collections.singletonList(subjectResource.getIdColumn())) - .build(); - parser = new Parser(parserContext); + setSubjectResource(ResourceType.ENCOUNTER); mockEmptyResource(database, spark, fhirEncoders, ResourceType.GROUP); @@ -707,6 +719,68 @@ void testIifWithNullLiteral() { .hasRows(spark, "responses/ParserTest/testIifWithNullLiteral.csv"); } + @Test + void testUntilFunction() { + setSubjectResource(ResourceType.ENCOUNTER); + mockEmptyResource(database, spark, fhirEncoders, ResourceType.GROUP); + assertThatResultOf( + "subject.resolve().ofType(Patient).birthDate.until(%resource.period.start, 'years')") + .isElementPath(IntegerPath.class) + .selectResult() + .hasRows(spark, "responses/ParserTest/testUntilFunction.csv"); + } + + @SuppressWarnings("SameParameterValue") + private void setSubjectResource(@Nonnull final ResourceType resourceType) { + final ResourcePath subjectResource = ResourcePath + .build(fhirContext, database, resourceType, resourceType.toCode(), + true); + + final ParserContext parserContext = new ParserContextBuilder(spark, fhirContext) + .terminologyClientFactory(terminologyServiceFactory) + .database(database) + .inputContext(subjectResource) + .groupingColumns(Collections.singletonList(subjectResource.getIdColumn())) + .build(); + parser = new Parser(parserContext); + } + + @Test + void testQuantityMultiplicationAndDivision() { + assertThatResultOf( + "((reverseResolve(Observation.subject).where(valueQuantity < 150 'cm').valueQuantity.first() * 2 '1')" + + " / reverseResolve(Observation.subject).where(valueQuantity < 1.50 'm').valueQuantity.first()).value") + .isElementPath(DecimalPath.class) + .selectResult() + .hasRows(spark, "responses/ParserTest/testQuantityMultiplicationAndDivision.csv"); + } + + @Test + void testQuantityAdditionSubtractionAndEquality() { + // 33 'mmol/L == 19873051110000000000000000 'm-3' + assertThatResultOf( + "((reverseResolve(Observation.subject).where(valueQuantity > 1 'mmol/L').valueQuantity.first() + 33 'mmol/L')" + + " - reverseResolve(Observation.subject).where(valueQuantity > 1 'mmol/L').valueQuantity.first()) = 19873051110000000000000000 'm-3'") + .isElementPath(BooleanPath.class) + .selectResult() + .hasRows(spark, "responses/ParserTest/testQuantityAdditionSubtractionAndEquality.csv"); + } + + @Test + void testQuantityAdditionWithOverflow() { + // values for 121503c8-9564-4b48-9086-a22df717948e and a7eb2ce7-1075-426c-addd-957b861b0e55 exceed 10^26 m-3 + assertThatResultOf( + "(reverseResolve(Observation.subject).where(valueQuantity > 100 'mmol/L').valueQuantity.first() + 33 'mmol/L').value") + .isElementPath(DecimalPath.class) + .selectResult() + .hasRows(spark, "responses/ParserTest/testQuantityAdditionWithOverflow_value.csv"); + assertThatResultOf( + "(reverseResolve(Observation.subject).where(valueQuantity > 100 'mmol/L').valueQuantity.first() + 33 'mmol/L').code") + .isElementPath(StringPath.class) + .selectResult() + .hasRows(spark, "responses/ParserTest/testQuantityAdditionWithOverflow_code.csv"); + } + @Test void testTraversalToUnsupportedReferenceChild() { final String expression = "reverseResolve(MedicationRequest.subject).requester.identifier"; diff --git a/fhir-server/src/test/java/au/csiro/pathling/fhirpath/parser/QuantityParserTest.java b/fhir-server/src/test/java/au/csiro/pathling/fhirpath/parser/QuantityParserTest.java new file mode 100644 index 0000000000..6e94165c4d --- /dev/null +++ b/fhir-server/src/test/java/au/csiro/pathling/fhirpath/parser/QuantityParserTest.java @@ -0,0 +1,56 @@ +/* + * 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.fhirpath.parser; + +import au.csiro.pathling.fhirpath.ResourcePath; +import au.csiro.pathling.fhirpath.element.BooleanPath; +import au.csiro.pathling.test.builders.ParserContextBuilder; +import java.util.Collections; +import org.hl7.fhir.r4.model.Enumerations.ResourceType; +import org.junit.jupiter.api.Test; + +public class QuantityParserTest extends AbstractParserTest { + + @Test + void lengthObservationComparison() { + final ResourcePath subjectResource = ResourcePath + .build(fhirContext, database, ResourceType.OBSERVATION, ResourceType.OBSERVATION.toCode(), + true); + final ParserContext parserContext = new ParserContextBuilder(spark, fhirContext) + .terminologyClientFactory(terminologyServiceFactory) + .database(database) + .inputContext(subjectResource) + .groupingColumns(Collections.singletonList(subjectResource.getIdColumn())) + .build(); + parser = new Parser(parserContext); + + assertThatResultOf("valueQuantity < 1.5 'm'") + .isElementPath(BooleanPath.class) + .selectResult() + .hasRows(spark, "responses/ParserTest/lengthObservationComparison.csv"); + } + + @Test + void lengthObservationSubtraction() { + final ResourcePath subjectResource = ResourcePath + .build(fhirContext, database, ResourceType.OBSERVATION, ResourceType.OBSERVATION.toCode(), + true); + final ParserContext parserContext = new ParserContextBuilder(spark, fhirContext) + .terminologyClientFactory(terminologyServiceFactory) + .database(database) + .inputContext(subjectResource) + .groupingColumns(Collections.singletonList(subjectResource.getIdColumn())) + .build(); + parser = new Parser(parserContext); + + assertThatResultOf("valueQuantity > (valueQuantity - 2 'g/dL')") + .isElementPath(BooleanPath.class) + .selectResult() + .hasRows(spark, "responses/ParserTest/lengthObservationSubtraction.csv"); + } + +} diff --git a/fhir-server/src/test/java/au/csiro/pathling/sql/PruneSyntheticFieldsTest.java b/fhir-server/src/test/java/au/csiro/pathling/sql/PruneSyntheticFieldsTest.java index 11e67184da..6a884e6f2a 100644 --- a/fhir-server/src/test/java/au/csiro/pathling/sql/PruneSyntheticFieldsTest.java +++ b/fhir-server/src/test/java/au/csiro/pathling/sql/PruneSyntheticFieldsTest.java @@ -54,7 +54,7 @@ public void testPruneSyntheticFields() { // Prune all columns. final Dataset prunedDataset = dataset.select( - Stream.of(dataset.columns()).map(dataset::col).map(PathlingFunctions::pruneSyntheticFields) + Stream.of(dataset.columns()).map(dataset::col).map(SqlExpressions::pruneSyntheticFields) .toArray(Column[]::new)); final Dataset expectedResult = new DatasetBuilder(spark) @@ -89,7 +89,7 @@ public void testPruneInGroupBy() { final Column valueColumn = dataset.col(dataset.columns()[dataset.columns().length - 1]); final Dataset groupedResult = dataset.groupBy( - PathlingFunctions.pruneSyntheticFields(valueColumn)) + SqlExpressions.pruneSyntheticFields(valueColumn)) .agg(functions.count(dataset.col("gender"))); DatasetAssert.of(groupedResult) diff --git a/fhir-server/src/test/java/au/csiro/pathling/sql/SqlExtensionsTest.java b/fhir-server/src/test/java/au/csiro/pathling/sql/SqlOperationsTest.java similarity index 97% rename from fhir-server/src/test/java/au/csiro/pathling/sql/SqlExtensionsTest.java rename to fhir-server/src/test/java/au/csiro/pathling/sql/SqlOperationsTest.java index a7ea4247ec..2edbc39b07 100644 --- a/fhir-server/src/test/java/au/csiro/pathling/sql/SqlExtensionsTest.java +++ b/fhir-server/src/test/java/au/csiro/pathling/sql/SqlOperationsTest.java @@ -31,7 +31,7 @@ @SpringBootTest @Tag("UnitTest") -class SqlExtensionsTest { +class SqlOperationsTest { @Autowired SparkSession spark; @@ -83,7 +83,7 @@ void testMapWithPartitionPreview() { final Dataset resultDataset = SqlExtensions.mapWithPartitionPreview(dataset, dataset.col("gender"), - SqlExtensionsTest::stringDecoder, + SqlOperationsTest::stringDecoder, new TestMapperWithPreview(), new StructField("myResult", DataTypes.IntegerType, true, Metadata.empty()) ); diff --git a/fhir-server/src/test/java/au/csiro/pathling/sql/dates/TemporalDifferenceFunctionTest.java b/fhir-server/src/test/java/au/csiro/pathling/sql/dates/TemporalDifferenceFunctionTest.java new file mode 100644 index 0000000000..d09f416ae4 --- /dev/null +++ b/fhir-server/src/test/java/au/csiro/pathling/sql/dates/TemporalDifferenceFunctionTest.java @@ -0,0 +1,43 @@ +/* + * 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.sql.dates; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import au.csiro.pathling.errors.InvalidUserInputError; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; + +@Tag("UnitTest") +class TemporalDifferenceFunctionTest { + + TemporalDifferenceFunction function; + + @BeforeEach + void setUp() { + function = new TemporalDifferenceFunction(); + } + + @Test + void nullCalendarDuration() { + final InvalidUserInputError error = assertThrows(InvalidUserInputError.class, + () -> function.call("2020-01-01", "2020-01-01", null)); + assertEquals("Calendar duration must be provided", + error.getMessage()); + } + + @Test + void invalidCalendarDuration() { + final InvalidUserInputError error = assertThrows(InvalidUserInputError.class, + () -> function.call("2020-01-01", "2020-01-01", "femtoseconds")); + assertEquals("Invalid calendar duration: femtoseconds", + error.getMessage()); + } + +} diff --git a/fhir-server/src/test/java/au/csiro/pathling/test/UnitTestDependencies.java b/fhir-server/src/test/java/au/csiro/pathling/test/UnitTestDependencies.java index d36257ace0..dedeedd2f7 100644 --- a/fhir-server/src/test/java/au/csiro/pathling/test/UnitTestDependencies.java +++ b/fhir-server/src/test/java/au/csiro/pathling/test/UnitTestDependencies.java @@ -10,18 +10,42 @@ import au.csiro.pathling.async.SparkListener; import au.csiro.pathling.config.Configuration; import au.csiro.pathling.encoders.FhirEncoders; +import au.csiro.pathling.encoders.terminology.ucum.Ucum; import au.csiro.pathling.fhir.TerminologyClient; import au.csiro.pathling.fhir.TerminologyServiceFactory; import au.csiro.pathling.spark.Spark; +import au.csiro.pathling.sql.dates.TemporalDifferenceFunction; +import au.csiro.pathling.sql.dates.date.DateAddDurationFunction; +import au.csiro.pathling.sql.dates.date.DateSubtractDurationFunction; +import au.csiro.pathling.sql.dates.datetime.DateTimeAddDurationFunction; +import au.csiro.pathling.sql.dates.datetime.DateTimeEqualsFunction; +import au.csiro.pathling.sql.dates.datetime.DateTimeGreaterThanFunction; +import au.csiro.pathling.sql.dates.datetime.DateTimeGreaterThanOrEqualToFunction; +import au.csiro.pathling.sql.dates.datetime.DateTimeLessThanFunction; +import au.csiro.pathling.sql.dates.datetime.DateTimeLessThanOrEqualToFunction; +import au.csiro.pathling.sql.dates.datetime.DateTimeSubtractDurationFunction; +import au.csiro.pathling.sql.dates.time.TimeEqualsFunction; +import au.csiro.pathling.sql.dates.time.TimeGreaterThanFunction; +import au.csiro.pathling.sql.dates.time.TimeGreaterThanOrEqualToFunction; +import au.csiro.pathling.sql.dates.time.TimeLessThanFunction; +import au.csiro.pathling.sql.dates.time.TimeLessThanOrEqualToFunction; +import au.csiro.pathling.sql.udf.SqlFunction1; +import au.csiro.pathling.sql.udf.SqlFunction2; +import au.csiro.pathling.sql.udf.SqlFunction3; +import au.csiro.pathling.terminology.CodingToLiteral; import au.csiro.pathling.terminology.TerminologyService; import au.csiro.pathling.test.stubs.TestTerminologyServiceFactory; import ca.uhn.fhir.context.FhirContext; import ca.uhn.fhir.parser.IParser; +import java.util.List; import java.util.Optional; import javax.annotation.Nonnull; import org.apache.spark.sql.SparkSession; +import org.fhir.ucum.UcumException; +import org.fhir.ucum.UcumService; import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean; import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.ComponentScan; import org.springframework.context.annotation.Profile; import org.springframework.core.env.Environment; import org.springframework.stereotype.Component; @@ -45,8 +69,12 @@ static PathlingVersion version() { @Nonnull static SparkSession sparkSession(@Nonnull final Configuration configuration, @Nonnull final Environment environment, + @Nonnull final List> sqlFunction1, + @Nonnull final List> sqlFunction2, + @Nonnull final List> sqlFunction3, @Nonnull final Optional sparkListener) { - return Spark.build(configuration, environment, sparkListener); + return Spark.build(configuration, environment, sparkListener, sqlFunction1, sqlFunction2, + sqlFunction3); } @Bean @@ -91,4 +119,11 @@ static TerminologyServiceFactory terminologyClientFactory() { return new TestTerminologyServiceFactory(); } + @Bean + @ConditionalOnMissingBean + @Nonnull + static UcumService ucumService() throws UcumException { + return Ucum.service(); + } + } diff --git a/fhir-server/src/test/java/au/csiro/pathling/test/assertions/DatasetAssert.java b/fhir-server/src/test/java/au/csiro/pathling/test/assertions/DatasetAssert.java index 162b1dba09..df1239b372 100644 --- a/fhir-server/src/test/java/au/csiro/pathling/test/assertions/DatasetAssert.java +++ b/fhir-server/src/test/java/au/csiro/pathling/test/assertions/DatasetAssert.java @@ -172,7 +172,8 @@ public DatasetAssert saveAllRowsToCsv(@Nonnull final SparkSession spark, log.error("Problem cleaning up", e); } - return this; + throw new AssertionError( + "Rows saved to CSV, check that the file is correct and replace this line with an assertion"); } private static class DeleteDirectoryVisitor extends SimplePathVisitor { diff --git a/fhir-server/src/test/java/au/csiro/pathling/test/assertions/LiteralPathAssertion.java b/fhir-server/src/test/java/au/csiro/pathling/test/assertions/LiteralPathAssertion.java index 82b30511cb..707391bfcb 100644 --- a/fhir-server/src/test/java/au/csiro/pathling/test/assertions/LiteralPathAssertion.java +++ b/fhir-server/src/test/java/au/csiro/pathling/test/assertions/LiteralPathAssertion.java @@ -12,7 +12,9 @@ import au.csiro.pathling.fhirpath.encoding.SimpleCoding; import au.csiro.pathling.fhirpath.literal.CodingLiteralPath; import au.csiro.pathling.fhirpath.literal.LiteralPath; +import java.util.function.Function; import javax.annotation.Nonnull; +import javax.annotation.Nullable; import org.hl7.fhir.r4.model.Coding; /** @@ -30,8 +32,9 @@ public class LiteralPathAssertion extends BaseFhirPathAssertion function) { + assertEquals(expected, function.apply(fhirPath)); return this; } @@ -39,7 +42,7 @@ public LiteralPathAssertion hasJavaValue(@Nonnull final Object value) { public LiteralPathAssertion hasCodingValue(@Nonnull final Coding coding) { assertTrue(fhirPath instanceof CodingLiteralPath); final SimpleCoding actualCoding = new SimpleCoding( - ((CodingLiteralPath) fhirPath).getJavaValue()); + ((CodingLiteralPath) fhirPath).getValue()); final SimpleCoding expectedCoding = new SimpleCoding(coding); assertEquals(expectedCoding, actualCoding); return this; diff --git a/fhir-server/src/test/java/au/csiro/pathling/test/benchmark/DecimalBenchmark.java b/fhir-server/src/test/java/au/csiro/pathling/test/benchmark/DecimalBenchmark.java new file mode 100644 index 0000000000..7b0770e6cc --- /dev/null +++ b/fhir-server/src/test/java/au/csiro/pathling/test/benchmark/DecimalBenchmark.java @@ -0,0 +1,148 @@ +/* + * 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.test.benchmark; + +import au.csiro.pathling.encoders.datatypes.DecimalCustomCoder; +import au.csiro.pathling.jmh.AbstractJmhSpringBootState; +import au.csiro.pathling.sql.types.FlexiDecimal; +import au.csiro.pathling.test.builders.DatasetBuilder; +import java.math.BigDecimal; +import java.util.List; +import java.util.concurrent.TimeUnit; +import javax.annotation.Nonnull; +import org.apache.spark.sql.Column; +import org.apache.spark.sql.Dataset; +import org.apache.spark.sql.Row; +import org.apache.spark.sql.SparkSession; +import org.junit.jupiter.api.Tag; +import org.openjdk.jmh.annotations.Benchmark; +import org.openjdk.jmh.annotations.BenchmarkMode; +import org.openjdk.jmh.annotations.Fork; +import org.openjdk.jmh.annotations.Level; +import org.openjdk.jmh.annotations.Measurement; +import org.openjdk.jmh.annotations.Mode; +import org.openjdk.jmh.annotations.OutputTimeUnit; +import org.openjdk.jmh.annotations.Scope; +import org.openjdk.jmh.annotations.Setup; +import org.openjdk.jmh.annotations.State; +import org.openjdk.jmh.annotations.Warmup; +import org.openjdk.jmh.infra.Blackhole; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.test.context.ActiveProfiles; + +/** + * Benchmarks for the {@link FlexiDecimal} class. + * + * @author Piotr Szul + */ +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MILLISECONDS) +@Tag("UnitTest") +@Fork(0) +@Warmup(iterations = 3) +@Measurement(iterations = 7) +public class DecimalBenchmark { + + private static final int ROWS = 100_000; + private static final BigDecimal LEFT_DECIMAL = new BigDecimal( + "12345678901234567890123456.123456"); + private static final BigDecimal RIGHT_DECIMAL = new BigDecimal("0.12345678901234567890123456"); + + @State(Scope.Benchmark) + @ActiveProfiles("unit-test") + public static class DatasetState extends AbstractJmhSpringBootState { + + @Autowired + SparkSession spark; + + Dataset dataset; + + + @Setup(Level.Trial) + public void setUp() { + + DatasetBuilder datasetBuilder = new DatasetBuilder(spark) + .withColumn("leftDecimal", DecimalCustomCoder.decimalType()) + .withColumn("rightDecimal", DecimalCustomCoder.decimalType()) + .withColumn("leftFlexiDecimal", FlexiDecimal.DATA_TYPE) + .withColumn("rightFlexiDecimal", FlexiDecimal.DATA_TYPE); + + for (int i = 0; i < ROWS; i++) { + datasetBuilder = datasetBuilder.withRow( + LEFT_DECIMAL, + RIGHT_DECIMAL, + FlexiDecimal.toValue(LEFT_DECIMAL), + FlexiDecimal.toValue(RIGHT_DECIMAL) + ); + } + dataset = datasetBuilder.build().cache(); + } + + @Nonnull + Column col(@Nonnull final String name) { + return dataset.col(name); + } + + @Nonnull + List collectQuery(@Nonnull final Column col) { + return dataset.select(col).collectAsList(); + } + } + + @Benchmark + public void multiply_decimal_Benchmark(final Blackhole bh, + final DatasetState ds) { + bh.consume(ds.collectQuery(ds.col("leftDecimal").multiply(ds.col("rightDecimal")))); + } + + @Benchmark + public void add_decimal_Benchmark(final Blackhole bh, + final DatasetState ds) { + bh.consume(ds.collectQuery(ds.col("leftDecimal").plus(ds.col("rightDecimal")))); + } + + @Benchmark + public void equals_decimal_Benchmark(final Blackhole bh, + final DatasetState ds) { + bh.consume(ds.collectQuery(ds.col("leftDecimal").equalTo(ds.col("rightDecimal")))); + } + + @Benchmark + public void lt_decimal_Benchmark(final Blackhole bh, + final DatasetState ds) { + bh.consume(ds.collectQuery(ds.col("leftDecimal").lt(ds.col("rightDecimal")))); + } + + @Benchmark + public void multiply_flexiDec_Benchmark(final Blackhole bh, + final DatasetState ds) { + bh.consume(ds.collectQuery( + FlexiDecimal.multiply(ds.col("leftFlexiDecimal"), ds.col("rightFlexiDecimal")))); + } + + @Benchmark + public void add_flexiDec_Benchmark(final Blackhole bh, + final DatasetState ds) { + bh.consume(ds.collectQuery( + FlexiDecimal.plus(ds.col("leftFlexiDecimal"), ds.col("rightFlexiDecimal")))); + } + + @Benchmark + public void equals_flexiDec_Benchmark(final Blackhole bh, + final DatasetState ds) { + bh.consume(ds.collectQuery( + FlexiDecimal.equals(ds.col("leftFlexiDecimal"), ds.col("rightFlexiDecimal")))); + } + + @Benchmark + public void lt_flexiDec_Benchmark(final Blackhole bh, + final DatasetState ds) { + bh.consume(ds.collectQuery( + FlexiDecimal.lt(ds.col("leftFlexiDecimal"), ds.col("rightFlexiDecimal")))); + } + +} diff --git a/fhir-server/src/test/java/au/csiro/pathling/test/benchmark/PathlingBenchmarkRunner.java b/fhir-server/src/test/java/au/csiro/pathling/test/benchmark/PathlingBenchmarkRunner.java index 03df73da26..f948420231 100644 --- a/fhir-server/src/test/java/au/csiro/pathling/test/benchmark/PathlingBenchmarkRunner.java +++ b/fhir-server/src/test/java/au/csiro/pathling/test/benchmark/PathlingBenchmarkRunner.java @@ -46,6 +46,7 @@ public static void main(final String... argc) throws Exception { final Options opt = new OptionsBuilder() .include("\\.[^.]+Benchmark\\.[^.]+$") + .exclude("\\.[^.]+DecimalBenchmark\\.[^.]+$") .warmupIterations(warmup) .measurementIterations(iterations) // single shot for each iteration: @@ -59,7 +60,7 @@ public static void main(final String... argc) throws Exception { .resultFormat(resultsFileOutputType) .result(resultFile) .shouldFailOnError(true) - .jvmArgs("-server") + .jvmArgs("-server -Xmx4g -ea -Duser.timezone=UTC") .build(); new Runner(opt).run(); } diff --git a/fhir-server/src/test/java/au/csiro/pathling/test/helpers/SparkHelpers.java b/fhir-server/src/test/java/au/csiro/pathling/test/helpers/SparkHelpers.java index 33ccde9113..a4600cedeb 100644 --- a/fhir-server/src/test/java/au/csiro/pathling/test/helpers/SparkHelpers.java +++ b/fhir-server/src/test/java/au/csiro/pathling/test/helpers/SparkHelpers.java @@ -9,17 +9,25 @@ import static au.csiro.pathling.utilities.Preconditions.checkNotNull; import static org.apache.spark.sql.functions.col; +import au.csiro.pathling.encoders.datatypes.DecimalCustomCoder; +import au.csiro.pathling.encoders.terminology.ucum.Ucum; +import au.csiro.pathling.fhirpath.encoding.QuantityEncoding; import au.csiro.pathling.fhirpath.encoding.SimpleCoding; +import java.math.BigDecimal; +import java.math.RoundingMode; import java.util.Collections; import java.util.List; import java.util.Optional; import java.util.stream.Collectors; import java.util.stream.Stream; import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import au.csiro.pathling.utilities.Preconditions; import lombok.Value; import org.apache.spark.sql.Column; import org.apache.spark.sql.Dataset; import org.apache.spark.sql.Row; +import org.apache.spark.sql.RowFactory; import org.apache.spark.sql.catalyst.expressions.GenericRowWithSchema; import org.apache.spark.sql.types.DataTypes; import org.apache.spark.sql.types.Metadata; @@ -28,6 +36,8 @@ import org.apache.spark.sql.types.StructType; import org.hl7.fhir.r4.model.CodeableConcept; import org.hl7.fhir.r4.model.Coding; +import org.hl7.fhir.r4.model.Quantity; +import org.hl7.fhir.r4.model.Quantity.QuantityComparator; import scala.collection.JavaConverters; import scala.collection.mutable.Buffer; @@ -98,6 +108,11 @@ public static StructType referenceStructType() { return new StructType(new StructField[]{id, coding, text}); } + @Nonnull + public static StructType quantityStructType() { + return QuantityEncoding.dataType(); + } + @Nonnull public static Row rowFromCoding(@Nonnull final Coding coding) { return new GenericRowWithSchema( @@ -137,6 +152,39 @@ public static Row rowFromCodeableConcept(@Nonnull final CodeableConcept codeable codeableConceptStructType()); } + @Nonnull + public static Row rowFromQuantity(@Nonnull final Quantity quantity) { + return Preconditions.checkNotNull(QuantityEncoding.encode(quantity, false)); + } + + @Nonnull + public static Row rowForUcumQuantity(@Nonnull final BigDecimal value, + @Nonnull final String unit) { + final Quantity quantity = new Quantity(); + quantity.setValue(value); + if (quantity.getValue().scale() > DecimalCustomCoder.scale()) { + quantity.setValue( + quantity.getValue().setScale(DecimalCustomCoder.scale(), RoundingMode.HALF_UP)); + } + // NOTE: BigDecimal precision is total number od digits (before and after the decimal point) + // while the SQL decimal precision is the number of digits allowed before the decimal point. + if (quantity.getValue().precision() + > DecimalCustomCoder.precision() + DecimalCustomCoder.scale()) { + throw new AssertionError("Attempt to encode a value with greater than supported precision"); + } + quantity.setUnit(unit); + quantity.setSystem(TestHelpers.UCUM_URL); + quantity.setCode(unit); + return rowFromQuantity(quantity); + } + + + @Nonnull + public static Row rowForUcumQuantity(@Nonnull final String value, + @Nonnull final String unit) { + return rowForUcumQuantity(new BigDecimal(value), unit); + } + @Value public static class IdAndValueColumns { diff --git a/fhir-server/src/test/java/au/csiro/pathling/test/helpers/TestHelpers.java b/fhir-server/src/test/java/au/csiro/pathling/test/helpers/TestHelpers.java index 3d6b6fcab2..b5ad4d1339 100644 --- a/fhir-server/src/test/java/au/csiro/pathling/test/helpers/TestHelpers.java +++ b/fhir-server/src/test/java/au/csiro/pathling/test/helpers/TestHelpers.java @@ -34,6 +34,7 @@ public abstract class TestHelpers { public static final String SNOMED_URL = "http://snomed.info/sct"; public static final String WAREHOUSE_URL = System.getProperty("pathling.storage.warehouseUrl"); public static final String DATABASE_NAME = System.getProperty("pathling.storage.databaseName"); + public static final String UCUM_URL = "http://unitsofmeasure.org"; public static final MediaType FHIR_MEDIA_TYPE = new MediaType("application", "fhir+json"); public static void mockResource(@Nonnull final Database database, diff --git a/fhir-server/src/test/java/au/csiro/pathling/test/integration/OperationDefinitionTest.java b/fhir-server/src/test/java/au/csiro/pathling/test/integration/OperationDefinitionTest.java index 280ea44a69..42df13b8cd 100644 --- a/fhir-server/src/test/java/au/csiro/pathling/test/integration/OperationDefinitionTest.java +++ b/fhir-server/src/test/java/au/csiro/pathling/test/integration/OperationDefinitionTest.java @@ -38,7 +38,7 @@ class OperationDefinitionTest extends IntegrationTest { private static final List OPERATIONS = List.of("aggregate", "search", "extract", "import", "result", "job"); - private static final String SUFFIX = "5"; + private static final String SUFFIX = "6"; @Test void operationDefinitions() throws MalformedURLException, URISyntaxException { diff --git a/fhir-server/src/test/resources/responses/AggregateQueryTest/queryWithDateTimeGrouping.Parameters.json b/fhir-server/src/test/resources/responses/AggregateQueryTest/queryWithDateTimeGrouping.Parameters.json index 961328ea38..0204efaf02 100644 --- a/fhir-server/src/test/resources/responses/AggregateQueryTest/queryWithDateTimeGrouping.Parameters.json +++ b/fhir-server/src/test/resources/responses/AggregateQueryTest/queryWithDateTimeGrouping.Parameters.json @@ -14,7 +14,7 @@ }, { "name": "drillDown", - "valueString": "(authoredOn) = @2010-06-19T18:35:39Z" + "valueString": "(authoredOn) = @2010-06-19T18:35:39+00:00" } ] }, @@ -31,7 +31,7 @@ }, { "name": "drillDown", - "valueString": "(authoredOn) = @1964-10-16T09:11:55Z" + "valueString": "(authoredOn) = @1964-10-16T09:11:55+00:00" } ] }, @@ -48,7 +48,7 @@ }, { "name": "drillDown", - "valueString": "(authoredOn) = @1959-02-26T08:27:40Z" + "valueString": "(authoredOn) = @1959-02-26T08:27:40+00:00" } ] }, @@ -65,7 +65,7 @@ }, { "name": "drillDown", - "valueString": "(authoredOn) = @2000-06-28T09:11:55Z" + "valueString": "(authoredOn) = @2000-06-28T09:11:55+00:00" } ] }, @@ -82,7 +82,7 @@ }, { "name": "drillDown", - "valueString": "(authoredOn) = @2016-12-12T19:04:32Z" + "valueString": "(authoredOn) = @2016-12-12T19:04:32+00:00" } ] }, @@ -99,7 +99,7 @@ }, { "name": "drillDown", - "valueString": "(authoredOn) = @2002-06-18T09:11:55Z" + "valueString": "(authoredOn) = @2002-06-18T09:11:55+00:00" } ] }, @@ -116,7 +116,7 @@ }, { "name": "drillDown", - "valueString": "(authoredOn) = @1959-05-29T08:27:40Z" + "valueString": "(authoredOn) = @1959-05-29T08:27:40+00:00" } ] }, @@ -133,7 +133,7 @@ }, { "name": "drillDown", - "valueString": "(authoredOn) = @2017-02-18T19:04:32Z" + "valueString": "(authoredOn) = @2017-02-18T19:04:32+00:00" } ] }, @@ -150,7 +150,7 @@ }, { "name": "drillDown", - "valueString": "(authoredOn) = @2017-11-18T19:04:32Z" + "valueString": "(authoredOn) = @2017-11-18T19:04:32+00:00" } ] }, @@ -167,7 +167,7 @@ }, { "name": "drillDown", - "valueString": "(authoredOn) = @1960-02-21T08:27:40Z" + "valueString": "(authoredOn) = @1960-02-21T08:27:40+00:00" } ] }, @@ -184,7 +184,7 @@ }, { "name": "drillDown", - "valueString": "(authoredOn) = @1961-04-07T08:27:40Z" + "valueString": "(authoredOn) = @1961-04-07T08:27:40+00:00" } ] }, @@ -201,7 +201,7 @@ }, { "name": "drillDown", - "valueString": "(authoredOn) = @2005-07-10T09:11:55Z" + "valueString": "(authoredOn) = @2005-07-10T09:11:55+00:00" } ] }, @@ -218,7 +218,7 @@ }, { "name": "drillDown", - "valueString": "(authoredOn) = @1961-09-04T08:27:40Z" + "valueString": "(authoredOn) = @1961-09-04T08:27:40+00:00" } ] }, @@ -235,7 +235,7 @@ }, { "name": "drillDown", - "valueString": "(authoredOn) = @2015-06-02T09:24:41Z" + "valueString": "(authoredOn) = @2015-06-02T09:24:41+00:00" } ] }, @@ -252,7 +252,7 @@ }, { "name": "drillDown", - "valueString": "(authoredOn) = @2006-05-28T09:11:55Z" + "valueString": "(authoredOn) = @2006-05-28T09:11:55+00:00" } ] }, @@ -269,7 +269,7 @@ }, { "name": "drillDown", - "valueString": "(authoredOn) = @1965-07-15T08:27:40Z" + "valueString": "(authoredOn) = @1965-07-15T08:27:40+00:00" } ] }, @@ -286,7 +286,7 @@ }, { "name": "drillDown", - "valueString": "(authoredOn) = @2007-05-23T09:11:55Z" + "valueString": "(authoredOn) = @2007-05-23T09:11:55+00:00" } ] }, @@ -303,7 +303,7 @@ }, { "name": "drillDown", - "valueString": "(authoredOn) = @1966-06-09T08:27:40Z" + "valueString": "(authoredOn) = @1966-06-09T08:27:40+00:00" } ] }, @@ -320,7 +320,7 @@ }, { "name": "drillDown", - "valueString": "(authoredOn) = @1960-06-26T08:27:40Z" + "valueString": "(authoredOn) = @1960-06-26T08:27:40+00:00" } ] }, @@ -337,7 +337,7 @@ }, { "name": "drillDown", - "valueString": "(authoredOn) = @2010-10-03T08:27:40Z" + "valueString": "(authoredOn) = @2010-10-03T08:27:40+00:00" } ] }, @@ -354,7 +354,7 @@ }, { "name": "drillDown", - "valueString": "(authoredOn) = @1961-10-03T09:11:55Z" + "valueString": "(authoredOn) = @1961-10-03T09:11:55+00:00" } ] }, @@ -371,7 +371,7 @@ }, { "name": "drillDown", - "valueString": "(authoredOn) = @2008-02-11T09:11:55Z" + "valueString": "(authoredOn) = @2008-02-11T09:11:55+00:00" } ] }, @@ -388,7 +388,7 @@ }, { "name": "drillDown", - "valueString": "(authoredOn) = @2009-02-05T09:11:55Z" + "valueString": "(authoredOn) = @2009-02-05T09:11:55+00:00" } ] }, @@ -405,7 +405,7 @@ }, { "name": "drillDown", - "valueString": "(authoredOn) = @2011-11-02T09:11:55Z" + "valueString": "(authoredOn) = @2011-11-02T09:11:55+00:00" } ] }, @@ -422,7 +422,7 @@ }, { "name": "drillDown", - "valueString": "(authoredOn) = @2013-10-16T09:11:55Z" + "valueString": "(authoredOn) = @2013-10-16T09:11:55+00:00" } ] }, @@ -439,7 +439,7 @@ }, { "name": "drillDown", - "valueString": "(authoredOn) = @2013-10-23T09:11:55Z" + "valueString": "(authoredOn) = @2013-10-23T09:11:55+00:00" } ] }, @@ -456,7 +456,7 @@ }, { "name": "drillDown", - "valueString": "(authoredOn) = @2016-03-16T09:11:55Z" + "valueString": "(authoredOn) = @2016-03-16T09:11:55+00:00" } ] }, @@ -473,7 +473,7 @@ }, { "name": "drillDown", - "valueString": "(authoredOn) = @2016-09-07T09:11:55Z" + "valueString": "(authoredOn) = @2016-09-07T09:11:55+00:00" } ] }, @@ -490,7 +490,7 @@ }, { "name": "drillDown", - "valueString": "(authoredOn) = @1980-01-13T09:11:55Z" + "valueString": "(authoredOn) = @1980-01-13T09:11:55+00:00" } ] }, @@ -507,7 +507,7 @@ }, { "name": "drillDown", - "valueString": "(authoredOn) = @2001-08-25T09:11:55Z" + "valueString": "(authoredOn) = @2001-08-25T09:11:55+00:00" } ] }, @@ -524,7 +524,7 @@ }, { "name": "drillDown", - "valueString": "(authoredOn) = @2004-05-26T09:11:55Z" + "valueString": "(authoredOn) = @2004-05-26T09:11:55+00:00" } ] }, @@ -541,7 +541,7 @@ }, { "name": "drillDown", - "valueString": "(authoredOn) = @2005-05-21T09:11:55Z" + "valueString": "(authoredOn) = @2005-05-21T09:11:55+00:00" } ] }, @@ -558,7 +558,7 @@ }, { "name": "drillDown", - "valueString": "(authoredOn) = @2006-05-16T09:11:55Z" + "valueString": "(authoredOn) = @2006-05-16T09:11:55+00:00" } ] }, @@ -575,7 +575,7 @@ }, { "name": "drillDown", - "valueString": "(authoredOn) = @2007-05-11T09:11:55Z" + "valueString": "(authoredOn) = @2007-05-11T09:11:55+00:00" } ] }, @@ -592,7 +592,7 @@ }, { "name": "drillDown", - "valueString": "(authoredOn) = @2008-05-05T09:11:55Z" + "valueString": "(authoredOn) = @2008-05-05T09:11:55+00:00" } ] }, @@ -609,7 +609,7 @@ }, { "name": "drillDown", - "valueString": "(authoredOn) = @2008-06-18T09:11:55Z" + "valueString": "(authoredOn) = @2008-06-18T09:11:55+00:00" } ] }, @@ -626,7 +626,7 @@ }, { "name": "drillDown", - "valueString": "(authoredOn) = @2009-05-17T09:11:55Z" + "valueString": "(authoredOn) = @2009-05-17T09:11:55+00:00" } ] }, @@ -643,7 +643,7 @@ }, { "name": "drillDown", - "valueString": "(authoredOn) = @2009-09-29T09:11:55Z" + "valueString": "(authoredOn) = @2009-09-29T09:11:55+00:00" } ] }, @@ -660,7 +660,7 @@ }, { "name": "drillDown", - "valueString": "(authoredOn) = @2009-10-18T09:11:55Z" + "valueString": "(authoredOn) = @2009-10-18T09:11:55+00:00" } ] }, @@ -677,7 +677,7 @@ }, { "name": "drillDown", - "valueString": "(authoredOn) = @2010-10-18T09:11:55Z" + "valueString": "(authoredOn) = @2010-10-18T09:11:55+00:00" } ] }, @@ -694,7 +694,7 @@ }, { "name": "drillDown", - "valueString": "(authoredOn) = @1977-11-20T09:11:55Z" + "valueString": "(authoredOn) = @1977-11-20T09:11:55+00:00" } ] }, @@ -711,7 +711,7 @@ }, { "name": "drillDown", - "valueString": "(authoredOn) = @2015-10-18T09:11:55Z" + "valueString": "(authoredOn) = @2015-10-18T09:11:55+00:00" } ] }, @@ -728,7 +728,7 @@ }, { "name": "drillDown", - "valueString": "(authoredOn) = @2019-04-14T09:11:55Z" + "valueString": "(authoredOn) = @2019-04-14T09:11:55+00:00" } ] } diff --git a/fhir-server/src/test/resources/responses/CapabilityStatementTest/capabilityStatement.CapabilityStatement.json b/fhir-server/src/test/resources/responses/CapabilityStatementTest/capabilityStatement.CapabilityStatement.json index 6a8cb2dda9..1880c7b2d1 100644 --- a/fhir-server/src/test/resources/responses/CapabilityStatementTest/capabilityStatement.CapabilityStatement.json +++ b/fhir-server/src/test/resources/responses/CapabilityStatementTest/capabilityStatement.CapabilityStatement.json @@ -1,6 +1,6 @@ { "resourceType": "CapabilityStatement", - "url": "https://pathling.csiro.au/fhir/CapabilityStatement/pathling-fhir-api-5", + "url": "https://pathling.csiro.au/fhir/CapabilityStatement/pathling-fhir-api-6", "name": "pathling-fhir-api", "title": "Pathling FHIR API", "status": "active", @@ -40,15 +40,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -69,15 +69,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -98,15 +98,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -127,15 +127,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -156,15 +156,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -185,15 +185,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -214,15 +214,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -243,15 +243,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -272,15 +272,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -301,15 +301,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -330,15 +330,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -359,15 +359,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -388,15 +388,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -417,15 +417,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -446,15 +446,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -475,15 +475,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -504,15 +504,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -533,15 +533,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -562,15 +562,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -591,15 +591,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -620,15 +620,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -649,15 +649,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -678,15 +678,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -707,15 +707,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -736,15 +736,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -765,15 +765,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -794,15 +794,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -823,15 +823,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -852,15 +852,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -881,15 +881,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -910,15 +910,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -939,15 +939,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -968,15 +968,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -997,15 +997,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -1026,15 +1026,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -1055,15 +1055,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -1084,15 +1084,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -1113,15 +1113,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -1142,15 +1142,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -1171,15 +1171,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -1200,15 +1200,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -1229,15 +1229,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -1258,15 +1258,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -1287,15 +1287,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -1316,15 +1316,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -1345,15 +1345,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -1374,15 +1374,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -1403,15 +1403,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -1432,15 +1432,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -1461,15 +1461,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -1490,15 +1490,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -1519,15 +1519,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -1548,15 +1548,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -1577,15 +1577,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -1606,15 +1606,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -1635,15 +1635,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -1664,15 +1664,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -1693,15 +1693,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -1722,15 +1722,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -1751,15 +1751,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -1780,15 +1780,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -1809,15 +1809,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -1838,15 +1838,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -1867,15 +1867,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -1896,15 +1896,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -1925,15 +1925,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -1954,15 +1954,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -1983,15 +1983,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -2012,15 +2012,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -2041,15 +2041,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -2070,15 +2070,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -2099,15 +2099,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -2128,15 +2128,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -2157,15 +2157,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -2186,15 +2186,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -2215,15 +2215,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -2244,15 +2244,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -2273,15 +2273,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -2302,15 +2302,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -2331,15 +2331,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -2360,15 +2360,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -2389,15 +2389,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -2418,15 +2418,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -2447,15 +2447,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -2476,15 +2476,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -2505,15 +2505,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -2534,15 +2534,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -2563,15 +2563,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -2592,15 +2592,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -2621,15 +2621,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -2650,15 +2650,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -2679,15 +2679,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -2708,15 +2708,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -2737,15 +2737,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -2766,15 +2766,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -2795,15 +2795,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -2824,15 +2824,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -2853,15 +2853,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -2882,15 +2882,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -2911,15 +2911,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -2940,15 +2940,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -2969,15 +2969,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -2998,15 +2998,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -3027,15 +3027,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -3056,15 +3056,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -3085,15 +3085,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -3114,15 +3114,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -3143,15 +3143,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -3172,15 +3172,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -3201,15 +3201,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -3230,15 +3230,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -3259,15 +3259,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -3288,15 +3288,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -3317,15 +3317,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -3346,15 +3346,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -3375,15 +3375,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -3404,15 +3404,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -3433,15 +3433,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -3462,15 +3462,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -3491,15 +3491,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -3520,15 +3520,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -3549,15 +3549,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -3578,15 +3578,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -3607,15 +3607,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -3636,15 +3636,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -3665,15 +3665,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -3694,15 +3694,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -3723,15 +3723,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -3752,15 +3752,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -3781,15 +3781,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -3810,15 +3810,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -3839,15 +3839,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -3868,15 +3868,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -3897,15 +3897,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -3926,15 +3926,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -3955,15 +3955,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -3984,15 +3984,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -4013,15 +4013,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -4042,15 +4042,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -4071,15 +4071,15 @@ "operation": [ { "name": "aggregate", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/aggregate-6" }, { "name": "extract", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/extract-6" }, { "name": "fhirPath", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/search-6" } ] }, @@ -4101,15 +4101,15 @@ "operation": [ { "name": "import", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/import-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/import-6" }, { "name": "result", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/result-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/result-6" }, { "name": "job", - "definition": "https://pathling.csiro.au/fhir/OperationDefinition/job-5" + "definition": "https://pathling.csiro.au/fhir/OperationDefinition/job-6" } ] } diff --git a/fhir-server/src/test/resources/responses/GroupingLiteralTest/DateTimeLiteral.Parameters.json b/fhir-server/src/test/resources/responses/GroupingLiteralTest/DateTimeLiteral.Parameters.json index 8cf190385a..e3c4b55d57 100644 --- a/fhir-server/src/test/resources/responses/GroupingLiteralTest/DateTimeLiteral.Parameters.json +++ b/fhir-server/src/test/resources/responses/GroupingLiteralTest/DateTimeLiteral.Parameters.json @@ -6,7 +6,7 @@ "part": [ { "name": "label", - "valueDateTime": "2015-02-08T18:28:17+00:00" + "valueDateTime": "2015-02-08T13:28:17-05:00" }, { "name": "result", @@ -14,7 +14,7 @@ }, { "name": "drillDown", - "valueString": "(@2015-02-08T18:28:17Z) = @2015-02-08T18:28:17Z" + "valueString": "(@2015-02-08T13:28:17-05:00) = @2015-02-08T13:28:17-05:00" } ] } diff --git a/fhir-server/src/test/resources/responses/ParserTest/ageAtTimeOfEncounter.csv b/fhir-server/src/test/resources/responses/ParserTest/ageAtTimeOfEncounter.csv new file mode 100644 index 0000000000..c3c42afdb5 --- /dev/null +++ b/fhir-server/src/test/resources/responses/ParserTest/ageAtTimeOfEncounter.csv @@ -0,0 +1,217 @@ +0134901a-4a69-4b39-92ea-d6f48ec83c6e,false +01ac1476-0c9c-4cd7-82a6-4ff526018e9a,false +0250a217-a663-403b-a708-5d14eadf0c40,false +02b993c0-b358-481c-b0d0-0767387feb9f,false +0364073f-91d8-47a1-b8b0-107c6318a691,false +04945715-8ad5-4d8f-bfda-ae26662a3610,false +04d88eb4-fb1b-4fa1-802a-5624f4c61b32,false +07bb3bb3-09e6-4abf-85f4-8ad113e7afa5,false +0af4a77e-892e-4b3f-9110-4c5224782250,false +0c315d37-c758-4cf5-a7cb-cbf712fa7dfd,false +102e16c5-4920-4dad-b142-0b280b2aacad,false +11dafd5c-85e7-4275-a147-89a63641e35e,false +12b212d8-bc6e-415a-93b0-594381726668,false +12df1bed-5472-4c48-8e88-2cbb3e5eab33,false +151e3048-66ad-4411-8753-677877e3bf0a,false +16a3408d-c927-4d02-a1ae-cad32419caab,false +16d280a2-c61f-487f-9034-22e884158969,false +17bcf2ea-d921-4715-91c5-6b15226b33d3,false +18ebf5ea-b0a2-4333-9e9c-40217de809ff,false +19502b5a-2031-487d-9d9c-2001f959408b,false +1cb88e7a-3db6-4a88-9b68-b0e1492114bc,false +1db1c71b-9eeb-4a98-abc1-eb699b38510c,false +1f3443ee-d15e-4894-b18e-185cfadfcdea,false +1fd714a6-48b4-425a-99b3-ba5c1a995cce,false +202131ae-78bb-4104-89b0-fb90645760f6,false +20fbcb6e-d793-4b05-8e29-8ff82572b0db,false +21995497-0eb8-4c0b-8c23-e6a829f3d596,false +21c6e0fc-bf47-4f80-b1ff-85b940445bdf,false +224e538d-3622-4f5e-b772-211ed358d8de,false +23780032-f3bb-4b40-af2e-3fa6b1677376,false +24c4dd5b-748b-4165-a0cc-2867b76c2dc2,false +2514cdf0-1216-4c5e-bfa8-0c11c20c6b93,false +274a2e49-9170-4945-bca2-ab6ef4bded75,false +2830e99a-e6b0-411b-a051-7ea1e9f815d1,false +29d4e919-2bd2-44e6-bb8a-380a780f60ff,false +2aff9edd-def2-487a-b435-a162e11a303c,false +2bd766e5-60e4-4469-bb97-54f0503a1eb0,false +2bddd98c-86e3-4ae0-9dc6-87da16ab6267,false +2cd8b9e4-2881-45a4-b1a6-c3a38e9d59d5,false +2d2e07ec-e697-4384-a679-867e93740921,false +2de1f829-c9d2-4f22-bf39-536dcb82fc3e,false +2e8eb256-84c9-499a-8bf6-bb39504373e1,false +2ec33cf5-d22d-414b-bf5d-e4b4e9997c0f,false +2ee2ab26-09fb-4e12-bf21-9fed3b4c38de,false +2fc75f11-2097-4e1e-8390-dbff3e844b7a,false +2ffd6142-b75b-406f-bc06-cdb1c02eaefc,false +308eba53-29fa-489a-97dc-741b077841a7,false +30ae4a13-0cc6-4d12-a5dd-fa9288efcc09,false +31d4c712-75b1-4ecb-9d1a-ccc4b8453826,false +3397a796-894d-409c-97de-a9e6f3f88198,false +359cb842-c25b-429f-ba9b-d52f171e5631,false +36160225-76a2-4cf1-8bf8-5a3d3f2ec9d7,false +374fd699-6b74-4500-9d60-2473c7e0364f,false +395019b6-84e8-4919-8b8b-ac64e4a6eade,false +39efc9b8-a75f-43a3-98a2-5bdc1c8207d2,false +3ddf46fe-b5be-456d-810f-ea6a7402236d,false +4148ac36-1dcb-4e96-89cd-355e7e8f919b,false +41d26b1c-57b9-408c-b955-bf0ee1db4809,false +4215b5d0-bdd9-4222-a04a-81bb637d60af,false +42a9a333-d09d-4b9e-af96-1f02af26bac3,true +42aa48c7-68cc-4bee-9730-cff29f0e36c5,false +4506aa76-9d0d-40e4-85bc-5735f74522a0,false +45b25ced-6eed-4fca-8ec1-b7d32ea13efe,false +45ec3b9e-eb82-48b4-b4b6-bd305afdf8b3,false +48cc2275-a478-4ade-b076-cf38e1d16017,false +498f4b18-bd4c-470d-9cde-2fca70ec8964,false +4a464bb5-9373-4f1b-9c03-053c64797114,false +4adcaf72-5241-4877-b61c-f34060576c50,false +4cc605d0-d0c6-4de3-849a-f5f92b35d2a0,false +4cd95073-6db3-4eb2-ac4b-0aacb182b352,false +4cfe72fe-21a0-4201-87b6-ef93695d2495,false +4db144d3-a596-4718-a50a-8ac9175ad386,false +4e6b69c7-61f9-4ff5-8c33-ad400edb9b06,false +4f14ca7f-5332-4263-a7b2-f0a838380309,false +4f342a71-dec3-403e-970b-e4c21b9eb98b,false +4f3d1e93-a28f-446e-91af-2baf0168b82b,false +50eac25a-3761-4de3-8a69-aae52e658300,true +51241857-a7a4-4517-96e3-21f797581f89,false +522e2abe-ad96-4d1a-b5a5-748faa997531,false +54c750aa-570a-4e8e-9a02-418781923e39,false +55f17f44-287f-41aa-a1bc-d1c0104af36e,false +56999896-e36b-4e63-a6b6-dbb85dfe1936,false +578cc35c-0982-4d72-a729-b304c026f075,false +5abe533b-ae5f-47ad-8746-f60caf7483c0,false +5cedf18a-fc44-4c39-a80f-2106a0d76934,false +5e1fe0f2-4517-462b-8287-7824f9a60f4f,false +5f64131b-d410-449a-9de6-35415919fec5,false +62059efc-7607-41c9-a3ba-70948f6a8a1d,false +634f0889-3a83-484a-bcc8-86f48e333c7b,false +67e5cf95-236b-4f75-abc5-034ca2966448,false +67fc12fc-bb9f-40f1-9051-127a788b3081,false +683714ad-5194-49e7-9b8f-4e306cf68ae1,false +6954c5c2-dd77-490a-9152-f1d78eff913d,false +6a5d8a68-bbe0-4408-ada5-a843ee6bd9b0,false +6af73cae-2e4e-485f-a74d-6f4307eb3af3,false +6c84348c-5065-4e89-9412-bfda023683f2,false +6d47a2fe-3645-4c5c-bebe-1b822eff197f,false +6e187f47-91a1-4217-a185-31b6f01db225,false +720f7ed6-7b2e-41dc-a0e0-724a3332aa24,false +721e4027-a080-40d8-bc4a-43cd33477611,false +72788e7f-1bf1-40b5-a1f1-27c669dc7278,false +72c611bb-471e-40f2-a6a8-0ae7b7b6b63e,false +749babeb-6883-4bd4-92a5-bec52769071c,false +75a09d4f-eef2-4404-a386-dfcb408ec9ed,false +777aa5f2-2a09-4aed-92ea-912694e28b48,false +79be3b69-23d8-4408-8f01-68d993e63b6c,false +7ac56d5a-32a7-4b40-a956-356e3006faed,false +7e6fe8ca-a95e-4102-8b18-e6e858cd15a8,false +7e7322a6-7912-4101-b3be-d134245a0626,false +7ea43fc6-b1f7-46be-a308-5ecb275a1081,false +7f410064-638a-4477-85c4-97fc2bb14a49,false +8089a9ac-9e71-4487-a231-f720e4bc8d3e,false +836b2e59-fb97-4014-ab0c-d5a5dc750969,false +85481b3f-c75e-40cd-bacd-b0afb79e893c,false +85c997bf-63d9-4ebb-8e0b-320de3dddc6c,false +85e41a01-04e5-44d2-8b3a-4d3ad7b0f87b,false +86415df5-7e47-4637-9e09-aaad9e7628d1,false +8743e69b-17aa-44ff-b8fa-4f582665efc6,false +87b04a97-1d33-4548-aec9-3d2856070702,false +88b16960-bfff-41d0-81e4-9a4630834a00,false +89f260bb-68b4-4dec-91f4-d52e673e0ff7,false +8a1908f7-47cc-4f82-859c-781a193e9901,false +8bc7af32-e5ad-4849-ba4d-b446db833ab4,false +8be81657-8ba6-4ec5-8ff9-4809367096ea,false +8dc2ce26-aec7-43c0-9771-350af4257ad8,false +8e9e848c-0547-4f2c-8b5f-e33d79bbed67,false +8f76d729-9f74-4cfd-be2a-8b033b568e18,false +900ce9fe-02d3-476b-902a-9467767ecdcf,false +922e2443-9cc5-421f-8310-9cd23f6e9f2d,false +96b2282d-1384-4cfb-9958-f009fb501626,false +97b42d67-8691-433d-8a31-dada076162ae,false +984067fc-3dfc-47b7-8ee0-4d9b27d43860,false +990c21ab-433b-4920-873e-f9dfc7103d9d,false +99fc3558-79f3-4d14-9aa1-ff63f621ecd9,false +9b2eb632-6f1a-4e97-912b-3c8378a1b11c,false +9b4f52b0-51fa-4ea6-b02c-2ed8478066d3,false +9bc516d4-7c82-4340-a90c-bb493f96fbe4,false +9e0b8dc3-65c4-490d-97c0-d5e3db944de5,false +9ed8703e-3b40-424c-9e98-b3b404051f99,false +a1228f20-7c50-4d3a-b88c-2d277ca79d79,false +a221198d-000e-497b-8b70-bb4d37f7bbe1,false +a2c3ee1d-ec35-4b26-9bab-12de3f47d604,false +a6790cbd-8349-432e-a976-5dfc07451203,false +a6b084fb-ada7-480a-9adc-f180d4eb1e2a,false +a6cb423a-7571-46df-83e2-ccc6820adb36,false +a89c0c42-c19f-4d7f-a15e-d04e043c92f6,false +acb2329d-b1c3-45c3-ad28-91a09aa521e1,false +add6d754-a075-4693-a33a-c061c9a368ff,false +ae7ddaef-4911-418c-8401-d978617e145b,false +ae9e663e-8c15-43c9-8a88-52b61cbf07a9,false +b00df815-7528-4967-bfe2-311130d91c21,false +b07fb98d-2da4-423a-83b4-7a673de93096,false +b0d337c5-3555-4817-ba59-4ceea5ad8a91,false +b1ccd55a-6b88-4240-b20c-ca893f36e23b,false +b1d4dc41-07ae-44db-ae17-1df86c5a62cf,false +b5d06aa6-b5c6-4782-a0f8-dbf4121e1baa,false +b6900c21-d310-4fb4-8b8f-176a09c91989,false +b7772635-1801-48e4-a442-f4aaa6860544,false +b870d2cb-ea6a-4b67-8de5-ce1224a18bf2,false +bac374c0-50e8-4a5c-947b-82a8e9a747a9,false +baf48725-f0f9-4357-a71d-b1104910deae,false +bb1a7816-4798-4f58-9ce4-c5bd3af682a8,true +bbd0f936-0cb9-4cc9-858c-2926b2b1c1eb,false +bf895c48-1d52-4780-8e9a-532d69356d28,false +bfc93cb7-e53a-49f7-b86e-81d6a13cfdea,false +c06a9f9b-90fa-4bd6-9581-0c6950f03e4a,false +c3ec1f2e-1411-41e4-8370-acd5a8f68cf4,false +c57d51a7-45de-41b9-92fc-efd0634effaf,false +c5c6eed5-aec6-4b8a-b689-adbb219c2267,false +c892b1d7-7485-407d-8883-54fb7fecebc1,false +c90aae7e-5704-4e13-8794-41ab377193bd,false +ca3e0486-fd6b-4a13-a741-3a47760b412d,false +ca7f269d-3794-4994-8c46-d8e9f2aa6378,false +cc56af6d-25c6-480e-9767-da02a55551da,false +cdb8493c-e3b0-447f-b16b-e58dd64660f3,false +cf67a8d4-48e2-4dc9-a521-6aabcff0330b,false +cfcbe34a-edc5-4442-bc05-5927fa00336b,false +d05461d6-13bf-402c-890d-db6404933f7c,false +d080c116-681a-494a-a928-45924109b49d,false +d535b213-2abc-438f-aa6a-c06476d60b09,false +d6988116-3c63-44f8-9f94-9e9d51cc5a37,false +d79728e1-8834-4f4a-8edc-ce18aca18be6,true +d7a48a26-7731-4046-bf22-78f0b8084eb9,false +d90676d2-ce74-4867-a00f-6dbffa7c00be,false +d9e7dd88-2d7c-4e48-8cf9-9e33f729b7c2,false +db79f75d-af3c-4f82-b4e5-9b5d26598eef,false +def5fd23-2b74-4c64-85e9-fac27e626bb7,false +dfe38e2d-23d5-45c6-86bd-f83fe3b6a1d8,false +e0dfbc08-45ad-4a81-b648-7e65c066f673,false +e1040d58-53bc-4467-8101-ca53b772cede,false +e1c2ad9f-6f61-4f16-805a-2f405b63659a,false +e2387a81-5ff5-4daf-b2e8-881998d0d917,false +e26ae29a-213a-4f79-98c2-cc81cf2f451d,false +e363eb67-64c7-440f-93fd-5c8787c69a85,false +e4358f28-62a8-4e06-b2bd-cb00d3310349,false +e7f68d35-ae55-4fa4-b0be-0672a5a7186a,false +e8c41168-a093-40eb-8baa-6802d24f554a,false +e8eba267-fecb-477e-9625-771fbcfc3cba,false +ede7745a-8f3e-4e20-9f16-33756be7ab6c,false +ee24bf89-81a3-4259-a382-86917f3829d4,false +f1293c5e-c997-4ba9-8bfd-438e7a840dc8,false +f18b08bd-40da-43c1-87ec-4ba23542635f,false +f19eefca-c1ad-4860-bdda-4674a631d464,false +f28931e5-1f35-4f9f-a02e-78398735ea67,false +f29330d0-5b32-4f75-b558-a1c7f05c0b4a,false +f2c9ca81-8b1e-4873-bd8a-1a6e1411193c,false +f3aa491a-4dbd-4436-b674-18b2177dcf18,false +f3c2f842-6aa3-42c9-a0f3-895c40456868,false +f3eb0c38-2571-44e7-be39-732eb52cf1df,false +f6d3ff7b-f6e1-416a-bb05-73dfa8d129b5,false +f77a8561-5adc-452a-ac9a-76273b6a6678,true +f883f2ca-d523-4c9f-86b2-0add137901de,false +fc4d37ec-22b7-4ea0-a34e-dcd4beb2001c,false +fc771883-3bd6-46d9-9626-a130e1b902de,false +fcab9efe-fb05-42d6-b366-ce6db1cc4093,false +fcc916dd-5e4f-4bf7-9aef-c906a36d7301,false +fce20464-ff98-4051-8714-6b9584e52740,false diff --git a/fhir-server/src/test/resources/responses/ParserTest/lengthObservationComparison.csv b/fhir-server/src/test/resources/responses/ParserTest/lengthObservationComparison.csv new file mode 100644 index 0000000000..e7abc33dc5 --- /dev/null +++ b/fhir-server/src/test/resources/responses/ParserTest/lengthObservationComparison.csv @@ -0,0 +1,1502 @@ +0020b035-7314-4867-9453-7921f158d003,"" +002593d4-d271-46a9-a900-1c498c322988,"" +00e9f82f-f16c-422f-81a3-77fa98958da3,"" +00f02590-e737-42c4-9c73-206cf66b02b7,"" +011f5b11-f944-46ae-9cde-0d802e5c0073,"" +0143f01c-3692-479a-9a72-592260dbbd64,"" +01a4de83-37d0-4612-82eb-2ff2dbc2e02b,"" +01c177be-05bb-4a44-a199-1df387e68d8e,"" +01c17bf0-9240-4149-983e-f0b3ccfb52be,"" +01d57966-1281-42ab-9e05-02d96d146b6e,"" +01e27cc9-c9c0-4c33-82f6-9507394f5f2a,"" +0218f780-899c-4c1b-9167-45e33d02acfb,"" +021bf465-c299-4302-99ca-e29a6d25bda5,"" +022ebe16-f618-4acb-9d99-88e23d686c34,"" +023a9220-3016-4202-8c7d-360d7d3bece9,"" +025aa37b-4ae6-473b-9ae6-c12eece968c5,"" +02741df6-79f0-477c-963c-8b3f8cb4374f,"" +02b87530-10e2-4009-8734-4196642cef1d,"" +02c07924-f5c7-4909-ab49-dec34c051dfc,"" +02c4fa06-3281-46a0-9bb9-c7b99497c91d,false +03365fa5-36d2-41b3-b3d9-1fea9f94c73e,"" +03555f06-db5f-4b8c-aae3-f6d2c547f499,"" +03610d59-94a2-41de-a039-c671241b075a,"" +038ced3d-5233-44c6-9a8c-1f6f9cc4be11,"" +03c7ba3d-8af2-44d1-a3c0-2c56b9fbc7c6,"" +03dadf3e-cdc9-4f63-8a4d-89bae77bd529,false +03e44215-f743-4c4e-8d19-aaf761f54503,"" +0429fff2-2839-45d8-b0bd-1d86aa92f966,true +042bb1e3-e5aa-471e-9e83-bb4a1b90af22,"" +043108b6-98cc-4feb-8ad0-1394cd10a289,"" +04367369-256f-4d47-b1ef-8014109ab46f,"" +04661736-24d8-41f7-9f05-af5682696df0,"" +05048b00-24df-4311-806b-2f9a7cc16380,"" +0531e6b8-2ede-4e12-a91b-cfe7e12e552e,false +054334cd-cfc9-4a1c-acf3-d0824cafd3a5,"" +055824d7-b398-40b2-8fed-bc40552fffce,"" +05643ef2-65e0-4812-b739-4fadfa3c066e,"" +05bed469-760c-439b-9729-0479a6550b76,"" +05c37921-dde8-4b70-869e-82680975ab77,"" +05daccae-2d73-459d-8aea-7ee75966e52b,"" +0624683a-8572-4885-b51d-2197dde395bf,"" +062ab32e-318d-4ff7-81ea-f3be53204988,"" +068d13a5-8b46-4a3b-aca0-ac9ffe70f998,"" +071b684c-70a5-4c93-8289-9630d25496d2,"" +072312b8-c984-4cb4-a4f8-97560368576d,"" +07279076-3064-44aa-b07b-346a7edf6abb,"" +072bd136-7e5d-49a2-b878-aaa2c7fde1f2,"" +0735b01a-c65e-4d59-9016-5e3bed1fcdcf,"" +0785f996-ee5e-46f3-8966-107235de4cde,"" +07906572-63db-4046-8dbf-1ae866664f41,"" +07d441b6-4e92-4d6d-af4b-7f38471fa45e,"" +07dfda29-5378-4a66-ac90-fcb7ec6283ca,false +07f5fcdd-3aa0-4ccd-9122-f9686886dbd4,"" +07f95b0d-656b-4830-ade2-864e58ac5ed6,"" +088cdf48-9645-4dbf-b824-8836d6a83d24,"" +08d37a26-1ec6-4faa-985a-10a9d0ee54a9,"" +092b1b96-4ad3-4716-850e-8056ccd456d8,"" +094a486e-7e50-4717-a0c3-07a456a4cd5f,"" +09541c80-54b4-4bb0-8776-37745a9ac36e,"" +09941e9e-ff5e-44e5-82cd-4c3865e39c01,"" +09ab1f16-7bff-44ec-aed5-8ba400930bbc,"" +0a005143-4645-4ce4-89d5-9d49dca18ec6,"" +0a40e26c-d0ac-4653-a54f-17e23ed9a0ce,"" +0a6c1262-dae3-4ec2-b911-0d1caca68302,"" +0a7887db-203b-4a3a-b5fb-cabe9a886074,"" +0ab96751-edf1-4941-981c-c6bdcba75380,"" +0ae172de-1755-46d4-8729-d3acc96ce82f,"" +0b6ee068-26bf-4f1b-8423-30f1c591861b,"" +0b95920f-7c6d-4b30-89da-51807a6aa557,"" +0bbc7111-589b-460e-a742-20f2131c9c64,"" +0bd78173-c348-41f1-9edd-884e3561ad47,"" +0c4242e4-1c5e-49d3-bf57-3810f8b88d56,"" +0c93a4a8-3b59-41f8-a7a5-22a9691710ab,"" +0c93c94d-b626-40b2-9561-52168c4961ca,"" +0cbe226b-6432-41c9-b3dd-0a14c6d54d7e,"" +0d1af4fe-50f7-4d8e-823f-192f8a08ec8a,"" +0d7a0166-7fb2-4e1a-b1e5-b03a53fb5602,"" +0dbafa74-2f5b-400e-b27e-fddeac8c28ad,"" +0df8e035-a226-425d-9684-a12d0c58b844,"" +0e03654b-d81d-4a62-8f53-b479e8ce3edd,"" +0e11e8ea-dc1b-4e8f-b809-39f0f07c7499,"" +0e8063ca-3601-4741-a2c0-c0381cc6098b,"" +0e92574a-cc09-4564-a2ff-1cdbc89d210c,"" +0e99ca14-e99e-4394-b962-59c66427218d,false +0e9cc169-ca91-4201-a78f-1b0f724507cb,"" +0ed9ee59-d968-443c-b7e4-c3732ec666e3,"" +0edd2d17-3ac8-427c-ae05-40c99b401484,"" +0ee77005-b9a1-4c51-a599-bd233897e431,"" +0eea9efa-148d-41d4-b05a-d39484526333,"" +0f13292a-a654-4473-b78e-c8f1b3328ff2,"" +0f67bae5-3bbc-4c7d-84f4-34583758335d,"" +0f68a16f-1c70-4d73-a9b2-fb384585526b,"" +0f7373d2-3052-4c98-9c04-7074250f44cc,"" +1016a9db-50e6-4c17-9e93-18a97b67269e,"" +1037da65-9451-48d1-a35d-bfcae76c2c60,"" +10a7d4aa-af9d-4d03-8d1b-bb53ed123f62,"" +10ad7a5d-e26a-4d4b-b063-239af96b0e87,"" +10b85b80-f6fb-4473-a3a6-266f610dcbc6,"" +10cd7171-38a4-4276-b911-bcc8092eff7c,"" +10fef9b1-6bdf-4eef-b6b5-e12504e8fc7d,"" +1104d152-e95e-4a6a-8225-ab200e4530b4,"" +11148ea5-efc3-47ad-8672-799331f8e491,"" +114ead73-4920-48fd-847d-f9aa1a99cab3,"" +11597b54-9453-4ddc-9171-2be17df7a511,"" +1167e4a5-ce86-48b0-8b96-6d70125e2f9e,"" +11a0c4d2-8908-4c0f-8e51-bf4be1605441,"" +11af3d82-bb56-464a-9203-8714c270f4a5,"" +11cc59ea-52cb-41e1-97e4-7ed651037442,"" +12254e32-b86c-45dd-93b0-c8cbee619a14,"" +12257920-12cf-4945-a72f-80551181d7f1,"" +1266203f-94c9-43ac-af02-a0b8db8a93dc,"" +12689eb6-84ee-4d28-9c65-3f3e305266f3,false +127b14bb-027d-4380-932e-ea34c76592d4,"" +128cf2ff-4f97-4039-983b-72e2dd3267aa,"" +1333fbed-c09d-4622-b22c-c67dd32e4583,"" +133a1365-e43c-4d92-a6f8-8c3947b13b65,"" +1359fe32-3275-4c1b-ba16-9dc903334044,"" +137d6ce5-93fb-4201-8bf9-0e97e9595b77,"" +13bf741f-7ad6-4a14-908f-cbfe18651381,"" +13f4a39d-ec9c-43b4-958e-be28a97972e2,"" +143099ce-8738-4ccf-85fe-63e54943c7f6,"" +146000e6-9926-43da-9322-de3bf31e8142,"" +147add3d-eba6-4cea-bbe9-823b44794b9a,"" +14a9ad6b-b7bf-4cdd-972c-bda91e5066bd,"" +14afc7c1-89c8-4740-a932-a76d579e98c3,"" +151df048-c17f-4a51-83a9-3de5f99be125,"" +1520180e-fb4a-4df6-80be-0b3d559c1049,"" +15268027-ae33-4f5e-9c2c-76327ccdeb44,"" +155d0003-f37b-45de-b34c-d611c2a2cf35,"" +15821e91-ec03-4e76-a909-d2f2a14c3219,"" +159c1f96-038f-4722-9e36-98f4dfdb6b66,"" +159c3713-0d0f-499f-8ff6-ecddd44b958a,"" +15d9442a-2018-4390-beef-55fd90cf6ea3,"" +15e70015-e207-49dd-93a3-7c0ea5cc456f,"" +1631e3a1-0eb3-4d16-a7e5-b0d8a8a9e630,"" +16af45f4-69d1-4190-9bca-b309c17bd865,"" +16be31b9-a434-46e2-a481-459c5584c907,false +170e5f14-b29a-4aa8-ba71-4bf381a38d1c,"" +17505b4c-c5e8-4acd-9d10-fb001190a8c5,"" +1795e970-0ce6-4d90-b198-32567c690869,"" +17d74e33-f6c3-4b19-8708-4110a2f55245,"" +18a57e28-9c23-4e73-9d90-3694f2e373f2,"" +18c6a217-c947-4e97-a764-c43f33a409fb,"" +18e59ddb-b9b9-401d-9239-0d2cb81936c8,"" +18ee3e63-a8a2-4004-a313-3e332af8a173,"" +190f22f4-5fe5-47e5-974a-fbbe63a676c3,"" +191232f1-58d7-4c4a-93a9-10aee15e5cea,"" +1913a538-60f6-4510-9a76-2466896d2a27,"" +193a64c2-63ea-4677-9302-b56e3f0531ac,"" +19a30860-10da-4a1b-abdf-0b03d7b8f370,"" +19b01508-db72-4c22-a5b4-4e015a3207f9,"" +19c965ca-c1ae-4eec-816f-73903fe43aa8,false +19d27e58-26a0-48ca-a199-88d48894da5c,"" +1a3ad6e3-cb5e-483b-babc-ba7d34ffacf7,"" +1a7b0249-5aa4-4b0b-adb8-2c958e137d54,"" +1ac6d3a1-d1a6-4b0c-b405-0aaaaf37c7db,"" +1adf64f4-1fb4-47f9-a8a3-0ebeb3e7f414,"" +1af4a596-d0c3-4f7c-a217-b83a0755c3b7,"" +1b091e60-4c4b-4fb4-b9b8-ee53bccc9b52,"" +1b251a42-a224-4a0f-9d36-44ecc8902d08,"" +1b29b772-b873-447b-8aa0-5dd5e9ee1b80,"" +1b614d48-0af0-4d09-a6af-4f3af065da14,"" +1b785bb6-a40c-48e6-a464-f8022ea3cdcb,false +1bb3d0c2-c6de-42ec-bd60-edc8e3ccd092,"" +1bdd0326-987d-445b-9514-2ea30d948093,"" +1c01b494-d0c1-4a99-b110-9de392bbcf69,"" +1c120e92-0385-4120-ac83-1b42191597b8,"" +1c32d0e8-7312-4821-aede-6745a83ea45b,"" +1c51f4a8-14a6-48ad-9821-c6408dd0cd33,"" +1c52440e-0063-4170-9cff-a3caaf7c63fb,"" +1c6dd7c8-4942-498d-a369-65fac6a837d6,"" +1c79c271-a128-41be-9537-1d744f4971a8,"" +1ce6a20a-2413-470f-86ca-2dacd8811e72,"" +1d9b87ab-8b41-4184-9519-fa9822f48aa1,"" +1da7f725-2fee-4f33-9a89-96253d2449fe,"" +1dcdb77f-b0e5-4b2f-ad4e-d446a6ffa079,"" +1ddc3c30-fccc-4e5d-a9b2-e09ac4f64dc0,"" +1e2bcc56-3121-4b1f-b9c7-7e5503b867db,"" +1e5b7df3-5e81-41c5-b096-d9b5409268ae,"" +1e75c4d7-b570-4339-8c0a-06bdfc9bb485,"" +1e84c68a-4e0e-4980-adea-e46ae2506896,"" +1ea31cfd-f340-4c68-a547-b76365abd1bd,false +1f170771-0d08-45db-a38d-da3c539b46b0,"" +1f182acd-6bb8-4031-aa86-2f3dd83b4cb7,"" +1f3e4d9e-1fec-4a71-98fd-4912ab64d3d2,"" +1f6b8ac1-b12c-4eb1-a158-25b15965294c,"" +1f8ad9f7-f796-4900-b10b-365fe442f2e1,"" +1fb81c48-c8d0-44e1-9b9b-df53ad7d9456,"" +1fcab6a5-85c8-41b7-a820-fe6e2d84eaba,"" +2031d9a4-3e03-47a2-ab74-6fe7f2fa4ba1,"" +20d47a7e-f7f1-475b-a9b5-6192f2fce0ca,"" +20ee5488-a11f-418a-86a9-cb981c2fdae5,"" +2123f57e-0815-49e1-aa34-994270134f3a,"" +2160f03b-4276-436a-8278-300bedd07f7b,"" +21936507-6a38-4d80-807d-0d7cb5ea0311,"" +21d2fab0-5092-411b-b752-4859134a7aab,"" +223cae66-3049-48bf-be7b-cf027c415743,"" +22440788-7e64-452d-9025-9a25e4d2be60,"" +2245208e-d17e-4bb7-9bd7-ac75ac0ba134,"" +22462877-9663-4c06-bb5e-040d76bb144f,"" +2253a94d-e511-42bf-a17c-599ae2d5cf0f,"" +226d433b-9abf-4e98-bf0e-47cb3a37b41c,"" +227d84f4-ec92-464a-b3de-f596866ce825,"" +228b1b4e-f5e7-4e33-91fc-b7cbe6979102,"" +22b95566-7a4c-47b1-92af-7e0ecbfee6fa,"" +230b746a-26de-434a-9774-54db1ad98a7c,"" +2324dacf-f221-4edf-bdf6-924449cc916c,"" +2381d397-0068-4d6a-88e1-a0257d81a323,"" +23831569-6aea-4071-820e-6eb5440acc1f,"" +23b4fe3f-62c7-4439-9364-247ceb9251c1,"" +23f91a73-1b46-414b-becb-918e84177886,"" +2439d9a3-6c58-4ced-a82e-27908ed3df94,"" +2450caca-d74c-4610-ac24-1fae13801eb7,"" +24d8f04b-f035-4a9b-b03f-75be9e244ceb,"" +25085ba1-43d7-4a60-82ab-e15c477313b0,"" +251e7497-4a55-42fc-8e6a-32febded738f,"" +2534b076-583b-4872-84e3-bc96bdee5ef0,"" +2583c0bf-6a7e-4100-a5c1-d249de6ec56d,"" +25da1be8-51c6-41fd-b48d-5227e804ebfa,"" +25e1a428-ab0b-40f5-ac25-1e9899458ec7,"" +2606b58b-a924-4128-b3a4-5e4b91deb692,"" +261583fb-e2d0-44c0-a677-00bd89a3450b,"" +26344e09-20c8-4405-b674-49638169a7a0,"" +266c347b-fa2d-4cc1-a2fb-fe1ba20fbc2e,"" +266cf373-c41a-4cc3-8600-c165a4349a6a,"" +26b4001f-2917-4bf5-bcbf-1ce9dc258171,"" +26fb6882-7f3e-44da-9100-58057c9aeec8,"" +277e09d4-cb89-4748-b9da-39bee94df8b3,"" +27a75a54-d318-4026-bd63-c80f73899376,"" +2803a9d2-2555-4bc6-9718-7a9dcabd6ce4,"" +2803acc2-63bf-49a3-b4fb-0dd0742fb816,"" +281d5649-179d-4c8c-9a0a-d1159a5df8f1,"" +28503262-5aab-44eb-bf51-6fb7534c25ab,"" +2866a0de-36ab-4ec0-a1e1-cce5c697ef85,false +286decfc-83d1-42e8-9a2f-880f145c71b3,"" +2875fd27-8c5b-46ec-91f0-ef3a7a7727b3,"" +28aa1696-dde7-40ff-bb7a-6c5b614405dd,"" +28e8966e-ba9b-4499-bc9c-7f51222e15aa,true +290440da-118e-4e8b-8d0e-d50043c24eac,"" +292aa324-379d-4b82-9750-4c8e23587f92,"" +29506f88-302c-4264-81b7-cf762de48615,"" +29546a71-e5a0-47ae-96da-421275c2cce1,"" +29676c08-88c7-4b0c-82c9-5f6d7dd51f68,"" +2974e695-f2e6-477f-91e4-da8eb654bf24,"" +298120fe-5dbb-4d99-902a-3a6783fc5b6b,"" +298e5099-df2f-4381-8259-b10d0b8c0570,"" +299c851f-3566-405f-a217-84c0703d859c,"" +29b17fc8-8e80-4d7d-93dc-bdba1f2cfb9d,"" +29bfab6a-d760-449c-9198-38e8c63574f2,"" +29d4d79f-8a85-490c-b52d-aaf3bcd9a100,"" +29e54cc5-b484-4818-9c3e-08074812dc7f,"" +2a0d7eba-2dbf-4566-af0a-c16161a8b189,"" +2a133e8f-4dd9-49fd-9e3f-5cf122294091,"" +2a67b2c1-18cc-45a0-ad53-825c73a3aa15,"" +2a71ca62-7f39-4c9b-b3de-6dfcf299298a,"" +2a7f0959-9d50-4ccd-88e1-6635f2502905,"" +2af24d01-6215-4c7b-88b4-6cee45a156f3,"" +2b265cf1-0763-4922-a403-e6f644ed95ba,"" +2b41d0b5-97d4-4a80-bf65-b62ac0cb530a,"" +2b4fd497-9f28-4c87-9b13-64f0d00c0cc3,"" +2b54e31d-4af9-4071-ad49-60cae644ba39,"" +2b60fba0-0143-4f31-8e4c-27236c7f41d8,"" +2b927027-35f1-488b-bb5b-127a8985cc5e,"" +2bc92150-c490-44da-a925-ebddec5cd953,"" +2be63080-a881-43df-95b5-e371df93c6bb,"" +2c018134-14c6-425d-8ab4-bc3974402b05,"" +2c3b614e-7860-47ad-9320-11c5f45d27b0,"" +2d358911-c5eb-480a-a9e6-a6fab52ad7c2,"" +2d45c298-d386-43ab-b3e0-ba07dc527a68,"" +2d6cb13b-fdfe-4219-bc13-7de385998bcc,"" +2dbd4567-e6aa-4e1a-996b-af8384f66b37,"" +2df38530-e49e-4ff9-93a3-816de29d9bfb,false +2df89473-f746-4086-a2f3-8ee2d4f63271,"" +2e0bc41c-fdfa-42ab-abdb-28f13cf2ca20,"" +2e13cb39-148f-4299-b74a-0a8e10092e9b,"" +2e45b9b5-8d45-4994-aaba-1fab72c77c5d,"" +2e6b11f5-cede-4152-bfe9-523b030a2bdf,"" +2e8c312f-53b4-4cd3-b6da-653c34945d76,"" +2ea2af0e-343f-47af-b0fe-6dea108836be,"" +2eb09ab4-c554-4536-a3ce-2979cfb988c6,"" +2edee289-e99a-4a53-a067-f83d29db4c2a,"" +2ee72185-ca8f-40e3-b82d-30408dc8c6f2,false +2ef91918-bdb6-4a6e-9c39-41d8c513b552,"" +2f1bbdc4-beaa-4d49-8791-6548094c7291,"" +2f24078d-9646-40fb-908d-2628d555dcb1,"" +2f260daf-8fb3-4fb9-a435-670ec8f0180c,"" +2f30832d-e6b8-4946-8cf4-0d8da5c359c0,"" +2f33b981-f22f-4983-b347-f81d7d72c50a,"" +2f3f7f7a-ba31-4c1e-8a23-c7d1eb1f255d,"" +2f5d7d1b-847e-430c-988a-40028f9f595e,"" +2f8b35f6-2b55-4ff0-8d79-5de7805d6da1,"" +2fc9f8c2-4a1e-4e8d-8d91-a6c3b3937e8a,"" +2fcfe30d-dc47-4eaf-9df0-7943a2c37fc5,"" +2feac451-2301-4ed5-8bca-baef62790656,false +2febeae3-eb61-4743-8ff9-42547a77a40e,"" +3006707b-dcca-41ce-b138-5d62e6b56984,"" +30371578-4ad0-498b-a491-4e194c7466fd,"" +305d5449-57c6-4362-83cf-55b4dae133de,"" +30ba9f80-e595-460a-abf2-b8f46a62e606,"" +31504825-77aa-4a0f-a634-ca806bd886d3,"" +3169cf91-33f7-4b7e-b49f-d4b884760685,"" +319dfae4-0305-4520-8ad1-9679383cb74f,"" +31acc736-076e-426d-8a32-426d91bf6511,"" +31e26c46-af6e-43a2-8e27-a8342f53e817,"" +31fd2352-7eb4-4ce8-9dfb-b3d3a1410c82,"" +322637fc-2d75-4a8f-89a6-a4c963869112,"" +32596eae-6236-4b3a-99fd-e50856971f59,"" +3286c996-861f-4fe3-90a8-86ec826cdf9a,"" +32bed860-5df5-4bbb-8bd1-c95c016561ee,"" +32d92e2f-d02b-4006-bf16-d1c535948e80,"" +32f3d9fa-6c64-49e8-a6dc-fb51679753e5,"" +330fde18-0a86-4e67-850d-fe1c8b376dab,false +3322da98-67e0-445f-ba1f-225eb7d297a3,"" +33333f69-f8a6-4def-a5f2-bab5a26bf054,"" +33826788-b600-476b-9843-17fbee2cd849,"" +33a0b9dd-c88a-46cd-ba8f-af3d4d6cfc27,"" +33ac0c39-1552-408b-97ea-a90c9187d61e,"" +33b22ef7-01a8-4e8f-8b5d-9aef37e46896,"" +33be0567-5c42-451b-bd71-c09f7de30524,"" +340dbb93-0888-4f47-b18d-0b86d3e40248,"" +341634fb-2646-4c69-b57d-b5f00ff4c83d,"" +3420a3d5-d5c7-402b-a4c5-02e7198c5b7e,"" +342699a7-cb58-4a9f-bb79-306483dfa652,"" +34335eed-f6c0-4e05-ba6b-1ecaa1fc121c,"" +346734fc-4798-48e3-8880-a603d52e9ca9,"" +346a282a-439f-48ac-875a-cc34643d70cc,"" +34a83c04-2ea0-4638-ab6a-0a4bb9a3ad4a,"" +34e44ce8-26fe-48c3-8fe8-5cd8f260aee0,"" +34ea288c-f987-476a-a8ed-0ab2c1b92833,false +3590f230-1be0-4c7b-afc6-5bffec9933ad,"" +35cf6113-d23a-476c-b18d-f86fbfb3ea2d,"" +36160c58-889f-4543-bf04-dd29cac9ce19,"" +361688f0-e909-4c9a-b5d8-10727c9a18fd,"" +365ca17e-d5b1-41d2-982e-3ca7afdc0a0d,"" +3669a209-82a0-4f9e-8026-43cebad7f3ab,"" +366fa6b3-9595-4624-ae30-20257ef4885a,"" +36957f27-97d1-483a-a8ea-bd5b1484ad12,"" +36c9ce76-e047-487a-837c-faffdb2676de,false +36cc6703-7757-4c6b-91a0-a43055c19bb6,"" +3732940c-2fa8-4301-942a-e58fd8d73421,"" +373609ea-276f-4b96-9c94-d96ad532246b,"" +37770a6d-bb26-4499-a6e6-2eb399a8ad07,"" +3793c189-6e61-4f1f-bb19-a01a306267d7,"" +379779f8-dbce-4dfd-b18f-ce0485b0d6aa,"" +37e1570f-2c29-418a-acee-6688b6ab4279,"" +37ea3114-1b65-4c47-9e65-4cbcf339f8c5,"" +37fa89b6-2f6e-4985-b733-1ee4b2fd59e2,"" +381dcabc-52cf-42e9-9624-d4e1270518a9,"" +383aa480-8db2-49ed-9542-c738af90f344,"" +38898dca-756f-4267-aa1d-1fe52a6e4749,"" +389079a9-b902-4212-a8c1-7187e818e016,"" +389a8f10-ad75-4d27-9d11-2c4ba0dc55a6,"" +38c329c2-4078-450f-ae85-e411b80f30ce,"" +38c7c98e-0372-4892-aea0-ba21ed298958,"" +38d59ef7-b207-4d55-b74a-a1da3d0c10df,"" +39d3bc28-0ce7-4d1d-9adc-bb9933568809,"" +39d7db36-7baf-43d7-8a0d-970ae00456d0,"" +3a1941c5-c6bd-45b7-b306-d2a1a51c5eab,"" +3a8a0b91-a492-42de-9b64-fc552476d8ff,"" +3aacaf9d-af9b-4220-a836-1d0c3cfd5245,"" +3ad5553b-58b8-46c9-8023-e1acb85be08c,"" +3b4bf6ba-0f27-4228-b6e1-c16dbf82e5cb,"" +3b7c654f-9a67-4402-a571-a5b0a61559ab,"" +3bae6ece-f05c-4e3d-81a7-64f10f907bb2,"" +3bb8d5a9-87a6-4155-8f3a-7a0c841672c1,"" +3bbe3af0-0f3c-41ee-9c41-70d89b411852,"" +3be31b98-5218-44c6-aa92-1e054793d9df,"" +3c496888-2ead-4d5f-afa4-8ab39b57ca03,"" +3c504a58-92fd-4b2f-a308-21a9588b1850,false +3c8d926d-3156-464b-b385-192257411798,"" +3d2c40b9-2ef8-46d7-8215-bb898170902f,"" +3d87abf4-a569-49b5-962b-32c11816a53f,"" +3dac5f75-f71c-4092-b87a-7b8434af633f,"" +3db4a850-ef45-4fa2-8eb1-b1cba4477d8d,"" +3dc0190f-39b2-4a1f-87d9-1ef41a73fa75,"" +3e4206fe-8856-46be-98af-d6fecd52db92,"" +3e58093d-c387-4a07-85c2-41a519d0c398,"" +3ebd1cdb-5546-4dea-ba79-a88aef933640,"" +3edb8e33-d674-4c25-aa75-7303da0229b9,"" +3f5c46c8-4a8a-4575-b169-6bfd5d752d98,"" +3f771434-cfed-4f34-9671-0ef302b5f9e7,false +40100d97-ad9a-459b-b044-66568d36c0bd,"" +408159a9-8c38-4cb3-9488-d83331f1762d,"" +40a1dd3f-6ffd-4463-bf71-42057ee61689,"" +40a75d7a-909f-4657-9ac1-5b56df539129,"" +40eec0cb-8f50-4f61-92a4-7682c48511f9,"" +40f3ae1e-4855-4d78-9fe9-c8348058088e,"" +4115b0b4-f738-405b-9351-ae11ba4bd07a,"" +411cbadd-c2d1-4fb3-8ddb-d8bcea3aa176,"" +41496990-adc5-44d1-96b8-15010bdecc89,"" +41a3cf00-0965-4c17-bfb5-247a7da43699,"" +41a86c21-2ea1-436a-86a3-9173c7d95d9c,"" +41de6042-e95f-4bca-ba69-f55293248f7c,"" +41ecc0b6-ae98-40e0-a836-9d26070e248c,false +42187018-d27b-4831-913c-575d07e33c54,"" +421e31e1-5ffb-4c6e-957c-728b6218d6da,"" +42350e13-ab61-49ef-aea1-802f6b7ea955,"" +423800b8-5a89-4eec-a12f-451c533fac50,"" +42895609-81ce-4cef-81db-069efe9a207d,"" +429c5342-c5ae-4c55-98aa-e4f7bf0b4670,"" +42ac25e5-8828-49bf-bb5c-a6001966c6ff,"" +42c5e47c-ede1-48eb-bc82-2ed835d67495,"" +42fe77c3-239a-4afe-ad76-8c221b543e32,"" +43179e01-e94b-4f83-bb60-60f181388048,"" +432bf1ce-0e8b-4621-b998-819fee53f80a,"" +43522eea-96c7-41f6-ad41-1c190cece6aa,"" +4358ee55-cc06-46a0-8b44-6b89d09c380f,true +4380d762-baa4-4c30-905c-59b33dbd793f,"" +439dfa4f-917f-40c5-9313-0d5dcf7ecf2f,"" +43bdfaaa-7474-4503-ad93-730d777e6db8,"" +4416e165-8ac3-43e0-a9e4-6c3e789ffdd2,"" +44233ad5-4eb9-4709-9c6c-e7797d9c9f1d,"" +44237e1a-31ca-4635-9ff3-e3c71f587972,"" +4442a5e3-5793-43ae-92ab-f2d87a70cc0b,"" +446f7fac-2202-4149-9860-fe48335349b3,"" +44713d16-f673-456a-881b-b0526ee36651,"" +44b741ee-bdb2-4732-b484-e435854de348,false +44dbff22-7cac-4f70-886f-b8ac2dea7130,"" +44f714c0-88de-43a6-b69a-4d62d8fee57e,"" +4522ef75-31ae-43e5-8e5a-5caf5c83fb35,"" +453cd2e7-723b-4e1d-b414-f46f9152edcf,"" +45467cbe-cc21-4822-94f5-82e1203056ad,"" +4546f579-74ab-445c-8619-431f60a6efdd,"" +455f8ebf-b074-4035-915c-91cd15380d72,"" +459f6da9-0eb8-4b26-85b9-a8f63c587fab,false +45a306de-3731-40c2-8bd5-2c0fee3b9f99,"" +45d45783-5a68-4c06-9b2f-88b7ea1f8347,"" +461bea3d-934e-46fa-a112-9a761140372a,"" +4672ebd9-08d2-43fc-ba92-ce13b587af3b,"" +4675fa7c-6ac8-4bef-8756-88f757370a10,"" +4680ae70-6d17-40fe-b55a-c3152ce8b246,"" +4687b275-d990-41cd-a146-2715079a8ecd,"" +47014b4d-07f1-4bef-9792-82c027525c0f,"" +473bf60d-dab0-4531-9903-95dc6680a660,"" +475e95a3-6d57-40f3-a0af-9daf1b35618b,"" +478fbabf-520e-48a5-b3a1-a3e535d64345,"" +47971ac1-1e72-4788-ba6f-bea608e59076,"" +47f066d8-abf5-4064-84fd-dfb05649e0fc,"" +4808c4d5-7733-4601-8401-632bf5924c06,"" +484a19b7-9816-4a66-8f0b-51cb5f146818,true +48693756-94c2-434e-ad88-e573e5278a6e,"" +48fae21d-0ac1-4e4a-93b7-ac4ba7c2a606,"" +49088daf-d19c-4bab-9084-c67f0fba2c90,"" +491118c7-998f-4d45-8b58-da724ac011e1,"" +4925b797-e285-4d02-9aed-dfac19b0875b,"" +492f6c9e-3e1c-4043-aa08-03c610da33a7,"" +49466fee-df56-4b9f-898f-96b65318d833,"" +495bdeba-9ab9-4756-b4e0-a4aa8b039a02,"" +496f0696-cee8-425a-81d8-1df8fd17e4bd,"" +49cce532-3ba4-4db6-b518-ea934588bfae,"" +49ee8b11-a7c9-455e-9a9b-835dd617e861,"" +49f41136-fc63-48a8-8ee2-b7536d3bf0e7,"" +4a6eb9f9-49a5-4d36-85dd-78512fbe593a,"" +4acf651e-af55-447d-bf0d-9adaef4cf6bf,"" +4ae0f855-534f-41dc-a4b0-879c771e3379,"" +4aeca194-6d0d-48ad-8fd4-6aea3be783fd,"" +4b322f4a-fa06-4509-9783-dbbf12960b77,"" +4b68a6bb-4fca-45ae-bfb4-b814c67bdac7,"" +4b86609f-db97-4a0b-9860-3ce519072521,"" +4bbf3839-bd13-406d-9f60-d9eb9daa4dcd,"" +4bd9e2b4-e195-4a83-ba1c-478e66a7bb5f,"" +4be334e3-94a8-4223-846e-39b5877e9ff7,"" +4be59cbe-d89e-4abc-aca4-410a7e8cf580,"" +4be72d80-9418-44de-ab47-e8f2f2b9f2e4,false +4c9a28de-ab9a-4e69-9ca6-375512c2f149,"" +4ca8a902-7ac4-4634-b1df-456175c39d14,"" +4cef34bd-c677-4647-b940-840a6868cb9c,"" +4d0e9887-c81c-4ea0-9026-41ceb9ec9a51,"" +4d45564e-e14c-4289-a637-06193bfcef2e,"" +4d79c0f1-72b2-4e94-addb-9adce3f49c2f,"" +4dad93cd-b188-4750-bdb0-4a5501568d81,"" +4db059c5-c4d2-440a-84ac-360312e3c590,"" +4dba5ae8-2d30-479e-b831-80d39c396280,"" +4de45bfc-2a41-4e0d-a0e7-c6caf6ca0f24,"" +4df7ae55-1947-4d89-b51a-496b34c4250b,"" +4dfadd90-3f14-4ee9-abbd-a348a5d6a7d9,"" +4e0d77a5-782a-4b03-8867-f51a9704368f,"" +4e74bab4-e328-447e-84d9-a29bb7fa1548,"" +4e8a0b34-71b8-4da8-80f9-f015782b182c,"" +4e9a316e-406b-496b-acf5-6eec80f25ee7,"" +4eab3a46-0ea6-431a-8c65-5b5bdee521cc,"" +4ec34b7a-8389-4d01-bca5-06e678089d41,"" +4f147e12-0e70-4ddb-b4e9-4ea25361f290,"" +4f18952b-be4a-4d77-ad4a-05276a6bce1d,false +4f3f5836-8683-49cb-b5e8-a9881796a202,"" +4f62ec59-e478-40ef-8617-e6ed599866f1,"" +4fe2d379-ba65-4ee2-a584-f0bc63a8523e,"" +5005cfbc-b57d-442d-976b-34164aeb1977,"" +504859eb-2ed0-4184-99f1-79f436fcd692,"" +5085d62c-dc5e-4f25-8f0c-700e57bb71fb,"" +508de40d-3c1a-4bfc-8713-11dbae730004,"" +509d7086-3120-4f61-bc92-4ab924f30ffa,"" +50a9341a-67f3-4d18-9118-373db23eea3c,"" +50b76e4f-6575-47f6-9e15-a96b58c492f3,"" +50dbd55a-e4db-406d-943e-7624d96c554b,"" +50fbe67f-8d29-41a7-8cc6-3df916cd922f,"" +5105a245-dc96-483d-9a0e-52b39e664d27,"" +5106bb8d-43a4-4783-97c9-42d707990a2c,false +51164c4a-fa5e-4246-80e4-a01e1d7707d6,"" +512a1f5b-9f83-4420-a4e4-978e33432dba,"" +5253d689-c7bd-441c-ab16-3721f1e3b5cb,"" +527721f5-443d-4367-84e8-0f15982e7587,"" +529479a1-36f6-4133-bb4e-2f3cf677626d,"" +52c03be3-5715-4edd-9809-ebff7e2ba57c,"" +52d51fd3-d0c8-4046-9ec3-1a3f523d0b75,"" +53010db2-bba4-4751-9f12-f51429c9c558,"" +53339064-e7f3-47b0-a5c6-ce77d50b7489,"" +537bd7f9-9f4c-4bf1-bc21-9d09dd655a13,false +53e5edab-cd6e-42cd-b6e3-a36d57be3685,"" +5441b3d3-b8e8-4e36-84c5-623e9b199daf,"" +54487624-db9d-43cd-b4a6-0b4d3934f7bb,true +54627df6-151a-4f3c-9fea-374217afba2b,"" +5496c32e-97eb-4f6f-a7ee-46bd2123f966,"" +55054683-a9bc-4c84-b1b9-6a1540e1168f,"" +55449cc5-a88a-4181-9550-5d2bb23a293e,"" +5565df4e-b483-407b-8816-ca9e8ddefc27,"" +5578c18e-84ae-4f7a-8cb6-ce285e1b1ff4,false +55936779-3082-43b8-a1e8-a8329bf19a8c,"" +55954c84-4a6f-4667-b070-5fa9185fe3d2,"" +55dc6b95-e01c-4812-a812-2cbf20de74cf,false +562f66c7-19ed-4d05-a14d-6aaa37e6eb16,"" +56617f73-b5fd-4e8b-8bd5-467af440f0a9,"" +569f7616-50c5-47c5-94c8-fa3b3097bc97,false +5703a2ef-ccc3-4ca0-b100-a1c567f1dfc4,"" +572e67ff-4f0c-49c4-b55a-36a958d3e02f,"" +5742e203-dd0b-43c6-9dfa-304240238737,"" +574873f1-84ed-4171-a51b-6a2c609e9afa,"" +5760bdfc-cbd9-4763-841a-bb31a972f551,"" +5781b9ed-eeb3-45d3-a364-43cf8ea348f6,"" +579a0bf9-87da-4887-9700-a5098cd7d720,"" +579eb155-01ea-4066-9dae-9ddce5ea2041,"" +57d84d96-a1fd-44ec-8460-588b477502a5,"" +57fa04a3-a8e7-4699-9115-95957be21dea,"" +57fec813-6327-4290-a2e2-ca74a04cccf8,"" +588b882b-0bff-427d-8b34-294f2fe55189,"" +58aa2384-e80d-4083-a173-ba534f152680,"" +591075a3-92bb-42b7-a6b7-d761add1ad2f,"" +598288b2-fa85-4bf8-9e01-2d0e86711aa7,"" +59857d17-d8e0-4932-b92c-97bd36a31d3d,"" +59a25b17-fe55-4592-abfc-0c22e237bbd9,"" +59b131b5-2db4-4877-bcc1-2206865df718,"" +59e29c4a-102b-46a3-a950-3babee7cfccc,"" +5a0eb3ab-86ce-467f-b389-94f026fe0f7f,"" +5a4bc06f-8ed6-4cbb-93f7-5c5faee7e855,"" +5a9300fb-d831-4b67-88b2-843d2eca4441,"" +5b0954c2-a2cd-4013-b866-a6e0474c12c6,"" +5b2730a8-6a24-4bf7-aacd-f56fd380c696,"" +5b44153a-1ea5-45a1-9d58-bbc0a474ce1d,"" +5b5f6d2c-1899-474a-afae-a98762630b06,"" +5b72c7eb-4584-45c0-9039-5fc762b1e50d,"" +5ba15ba9-7112-45ab-b7e5-353d52af5fe3,"" +5bb09da7-8ce1-4642-a113-fdd1fbc73897,"" +5c085687-51d6-4cbe-9b71-0a58718c1d24,"" +5c17c3d7-a7ba-4756-9991-97bc0b3a46ad,"" +5c48ba78-4e71-441d-b03e-ef305d9e2bde,"" +5cce02c2-3537-4d34-b085-7cf145590292,"" +5cd558f0-20d1-40c7-8197-5a41ef97e634,"" +5cec04b3-e52d-4a6c-af98-6ee5d104b20a,"" +5cf73976-33ee-44ac-aade-5c64e56d7cd9,"" +5d54c744-365a-4db7-9675-79d64bdf55a6,"" +5d5dad82-9b58-4302-a494-02f44c3e94bd,"" +5d790c80-5b87-4802-9b89-02f949846f39,"" +5d883f31-f417-4d8b-bdbe-2cf73d1aa4b5,"" +5d9e8c9f-8c95-4ca2-9de2-2cf875868ff9,"" +5ecf975d-fa2b-4c6c-a5e6-fed730c9e035,"" +5ef7c113-d5bc-486c-9be9-aa39aea779d0,"" +5f6ad8e2-eed9-4b2d-8697-4e2e742ee1d4,"" +5f92feba-5842-4894-907b-9ceaf36d0f38,"" +5fc1d33e-168e-435c-93ae-c619999b6f9b,"" +5ffb50f0-0963-43d0-b032-3e6b2621e1d7,false +602f4e55-f69c-4103-bb6e-7d23fd1b06ac,"" +6042dc41-8cdc-4825-9ab2-bb22af5c5fa6,"" +60635e6e-3d74-4f56-acb3-be8edc522837,"" +60959eb0-ed9b-4043-b8a1-0b0f27789642,"" +60996e5d-082f-4d1e-8cc5-6cc626974925,"" +609a5704-81f0-4b67-881c-d00e87b74c0a,"" +6198d258-17e2-4956-8064-1448f4744303,"" +61e75b9d-46a2-4d74-a0f0-37dc66a09450,"" +6220b92e-946e-449a-a2bd-3241e6a453a9,false +62346d78-6be2-4cfb-850e-6ca1fc3f5e35,"" +62348772-d9cb-476a-a016-32f16e44cb33,"" +62ad1938-6235-48d8-aafb-2f773a40c6e1,"" +62ccafe7-fbcb-4cbf-8584-224cd58ef421,"" +62e4244f-3f34-48f4-b865-c8b1c3ad97f5,"" +62f342e2-5499-47c8-959c-4d786aa5fd67,"" +62f6ce69-77ca-436c-9d40-3eb541853798,"" +6320229b-25c2-4355-a288-17efb054df6f,"" +633dac04-7a54-476c-8482-9631c351ac26,"" +639dab1d-3282-4de9-84f7-727d0462f11f,"" +63b2b9b1-aaf2-4539-97f6-aa6815e75f21,"" +63d6c1e2-ce14-4e89-9bcc-f3e3e0b6fe72,"" +63e5b7be-525c-4a0b-852f-4cb090178d30,"" +63e709bb-a56a-452b-a48c-5125a367572a,"" +641068ee-0805-4403-a159-4fdb185cfdad,"" +64115066-e659-4cd0-9a56-fcd43a6df27d,"" +64148c8b-89e4-4394-b044-27088ab3adc6,"" +6433bbab-cad9-4e98-b488-c06e37acf268,"" +645572a4-5806-4854-b89c-939463a904f7,"" +64a2df8b-688c-4368-b672-0406ac7032ad,false +64c6ac23-d619-44aa-88fc-969376bebfcb,"" +657aed74-c373-4c45-9de7-b75cdf62577f,"" +65ad0ff6-ba27-4eea-a400-3d96240a5702,"" +65b9a660-2f5f-4d9b-9f15-5e572d65ee9a,"" +65e87fc6-9232-4ba9-baae-61d7af6e54f4,"" +66037242-eaa2-43af-98ed-190c3079833e,"" +667d62a5-160b-4657-be40-beeb787d51d7,"" +6683a92d-2d09-4875-9403-b977bc2eb37f,"" +66be2f9e-fffe-454e-86ae-75dc713ee934,"" +678223e6-745c-4d58-888c-b910dbb9039f,"" +67cf1dde-11a3-4aff-a7f2-a8b8288aac8e,"" +67ed7f4f-4873-409b-a04a-b928cb461719,"" +68059a10-b5eb-41c5-bb44-c56ecdb6baf1,"" +68249708-6a5c-474d-b1f1-214514fe5dbb,"" +682b9750-e94b-4522-b277-0d572b67e94d,"" +68935870-c60d-44c5-b57a-000c0a99e9d2,"" +68a1d32e-915c-417d-98c9-3154ffbc9249,"" +68a84b5d-edb4-41ee-82aa-8612ab7b2b38,"" +68dc301a-6b81-449d-bcf0-7b2f3d3335db,"" +692cc2c1-44b0-4c47-86b1-2d3c4a5848bb,"" +6938bd7d-06d6-4a9d-8234-9123aa238788,"" +697d10ec-d72e-49b1-b2f9-ac8a3be5c856,"" +698df1c2-7cc5-44cc-ab61-5420d92c598a,"" +699d6871-1043-4581-8dfd-fd1b6e47d518,"" +699f0f86-fc10-4f15-9a78-19515e4e4958,"" +69ae7f71-a967-4c7e-a046-cef77b622f70,"" +69c3f870-e1a5-4785-8dc4-067a7590b949,"" +69e71f61-bde7-494c-b65e-346f5972d21a,"" +69fe60c1-d372-41ec-8671-94090b970a7f,"" +6a4adab1-6b87-4e61-a400-dfa4aa4af613,"" +6a50955b-b259-464b-b3ab-9fa173caeaa5,false +6a8a69b4-f6d9-457e-8466-fdf87ac0585c,"" +6a967445-47ae-46aa-8754-2e48915efc2e,"" +6aba4aa4-9fe6-4759-9f76-705127be70c0,"" +6b8c1da8-2bca-4e16-a04c-a99a04c76d85,"" +6b9af3c5-cc2a-40af-9264-1c68ea98d031,false +6c18b368-8579-42e7-b0da-3500ed15ab82,"" +6c3be815-1494-4c82-b655-a3e7c92ee945,false +6c7689e6-db2a-4544-bf19-0b70c6d74279,false +6ca383d2-551e-4c89-b07f-c0faf9b36dcf,"" +6cac250a-d650-4c9d-a896-b38dd7e72955,"" +6cc22c4d-6014-44f6-a1e9-0b8eaf3f837a,"" +6d2776a9-6add-4222-bb43-64bd4dda65da,"" +6d34e7f6-d885-49f6-b072-6d06f6677a2d,"" +6d564224-4c2f-4bbc-af57-9895ad3b57d6,"" +6d5ff978-ef70-4eba-a1db-536985901dce,"" +6d759795-d565-43ce-90d5-91b167b18c10,"" +6d813c64-a15b-4e50-af82-c2f18f82a0cb,"" +6d94712f-7565-424b-ad4a-e1789fe2a639,"" +6d955124-bd23-4958-bad6-b36cdad50a5a,"" +6d986c2e-b12b-4a6f-ac80-d3bcdaede076,"" +6e02f522-f081-402b-88f2-38e6622bd006,"" +6e362fd8-b0b4-4cff-85c3-6586920627ad,"" +6e750faa-cf8a-4f5e-a02d-1471741cfdab,"" +6ea2fcf1-31dd-46e4-be06-592626e212f5,"" +6ea7ff7c-35f3-4350-9f9f-104c5182cd0b,"" +6ead6acc-52c8-4df1-b00e-b46e2e2f0a04,"" +6ec2fab5-4d76-4c80-ab2d-577b041c1aee,"" +6f550b68-a7cb-4314-ba74-d7d2a6d56d0f,"" +6f63c413-6f3c-48db-990b-fcc749cc6355,"" +6fb0d554-b14a-4bbb-aa5f-a4d5c082c2dd,"" +6fd78455-d026-412e-ab31-d9e1a02923dd,"" +6fdefa93-f23b-4eab-82d0-1e9ce7c6c17c,"" +70777428-a2a0-4dd6-b048-1ef2a27d9ec6,"" +7084e394-9ee8-4b0e-a3f5-e8d091ab4fae,"" +70a25de3-45dd-4848-a394-e87d4f6b6930,"" +70af4c33-277a-4a9b-8022-60d6bb0ac6aa,"" +7102c0da-2afa-4da2-a79b-a82742e4e3da,"" +713231d3-d739-455e-a913-41d5a1dc8571,"" +71f73b19-86e6-494b-8038-46a67396de4b,"" +7227c5bf-3699-48cf-a0c4-fb8f5d50540d,"" +72619c45-9cb0-4abf-a98e-20cc49a4e4f8,"" +7287ec50-e64d-418f-a83d-0d3d93981f62,"" +728f469e-7a39-4a77-8118-944f83c2cf21,"" +72972472-355f-4538-b69a-23aee8614438,"" +72baabec-7047-49ff-9e67-338361a06e5f,"" +72dd2d03-e239-4a2c-b509-769886057217,"" +73364971-4250-436d-b85e-93df377b2911,"" +734b53ff-038a-4c79-91e5-c14340b43145,"" +73fe21cd-4493-4afb-ba72-376f75bc2469,"" +7409225f-77a9-474b-889e-38eb4db0da2f,"" +74556136-3dd8-4074-8e26-160ae1b5f780,"" +748bb216-e420-46e3-9aef-6fe6b2020a74,"" +74cfd92e-5da2-4fae-be59-1546f5a22e35,"" +74dbc21d-e056-4050-8f0f-04194ac43995,"" +74eca765-7327-44ac-9868-ed01c1dc163d,"" +751225c7-3a03-40d5-980c-89f6020bc2ca,"" +752045ea-d278-4939-a82f-3ef29dd7616a,"" +752b713a-e049-403f-9d4a-f560ee0d4681,"" +752f97cd-9398-4830-ad13-38e26e3a8bcb,"" +753ae998-68fb-4917-93ed-484ef1753d9e,"" +75509cde-925c-4645-9a91-c1f244863842,"" +7569ce07-0cbd-4a30-bab7-d5f482a27883,"" +75969f3d-bddc-4e9c-8872-a33f108027a2,"" +75a6eba8-9d1c-4de1-b084-00a5aff10eab,"" +766ee5bf-c1a3-4837-8ee4-0c81e7252c91,"" +7690d499-c3d6-4092-89b7-81b3425164be,false +76a04620-5da7-4914-a5b7-5a8506221f16,true +76b1d775-0f28-4bdb-b6cc-a2441e8e17b9,"" +76cb0eb7-3679-4104-8121-9e01d36de541,"" +76d885d5-454a-4541-8ec8-61f7972f17f7,true +76f4f348-f65f-42da-a338-1e1f28df0ffe,"" +770f3f03-8a4b-4e32-8443-49b14d54ad3b,"" +7714ce28-a83c-48dd-a84c-ba3565432818,"" +7728c15e-82ee-48c2-90a4-afa79e048a52,"" +77293357-c730-4960-a8aa-c25ea0775c3f,"" +773da43c-fa5a-4a21-85c1-724b9d72bbbb,"" +776cf7db-0b09-48dc-b089-2d24410ed4d0,"" +77a645b1-5231-4486-8f16-0470ecc3e49f,"" +77a7196b-7391-4a38-89a1-e01b15e9e2a6,"" +7879670e-7953-4dc8-86ce-88f346cee653,"" +78a727b9-5bb5-4ed3-aec3-a3f804c79734,"" +78bfe231-0661-4502-b18d-28c24b223dce,"" +78edeaed-91f4-4f03-ab2d-38b720e5e6df,"" +7914b992-59e8-4541-8250-427de113802f,"" +794a6b0e-1e0f-4c12-ae52-47b53f385a03,"" +7957634e-ec90-46dc-9779-fb000649bd40,"" +795d85f9-c2d4-4219-8e06-f6fbcef30e33,"" +7968bcd8-e538-443f-b4a6-e41b9766965b,"" +797ac9d5-9ef4-49bd-af56-1bd0c971467e,"" +797d8c9f-56eb-4487-ae30-5c4dca379bf9,false +79813005-389e-4671-850d-b9a5fbc2345d,"" +798cfbc1-a7b2-47cb-91af-43af0ae0119f,"" +79a428bb-83a1-4338-a613-9b732f6feb4d,"" +79c5ee51-42c7-4fc0-8e8b-7ce9acb5133b,"" +7a281b03-7145-409f-9c5a-c45b6e544a4c,"" +7a543c90-f6bd-4343-8311-6818c3a9066e,"" +7aa8cd33-8365-4c53-ad1c-e07dcf2f86dc,"" +7ab27dbd-f952-44d9-bd9a-f67d5790fc82,"" +7b4255ec-4801-47ee-b12e-4b874c5eec1d,"" +7b8c6a88-3a53-48bd-9b73-bdc3f087e6b7,"" +7b9a52de-eb76-473a-a622-4b19d50b6bc9,"" +7ba6211d-542d-4508-96fc-712328eefc69,"" +7bb75949-ef13-4934-a19b-798f6a5e7866,"" +7bdf88dd-7924-4b93-9ff3-d543a170e0d8,"" +7bf5b1d8-3edd-458a-9730-187ac6738857,"" +7c197c69-7872-44cc-93bb-c518b8403da2,"" +7c6c40db-df29-4b8c-8881-3f1765e51c2d,"" +7c6e1d99-bc80-4172-b76c-226f6a618b48,"" +7c85bdf0-7156-4555-aa37-49e4195ce0e4,"" +7c94eac0-d189-4107-9443-452d124db20f,"" +7ce02db8-4ca5-42c9-afe5-b818e42e1767,"" +7d4a09ac-d7e0-4675-a9f0-313c73fa7906,"" +7d83ed97-4c6b-4ba0-9dd2-423f59e8bba2,"" +7da3d62d-56ee-4707-b036-2c1b5e111aff,"" +7de9fea9-9923-4dec-9c83-1cf13b81ca39,"" +7df8f003-7458-4083-8ef6-20a049526c19,"" +7e194149-713e-46fb-ab75-4a7cc2acd94f,"" +7e618ba1-1acc-4c2d-9b80-fee3d12884c9,"" +7eb4427c-1b25-405e-8ef1-38fabbfb1a0d,"" +7ebecbcf-c963-4cae-9b1a-8fe44e175008,"" +7ec8d0b4-41e3-40c7-8f18-fa10b249e023,"" +7f054bf1-9bff-4ade-8841-ebc67d4299c8,"" +7f35f61b-9551-45f5-9641-c9a74d7ef110,"" +7f8f71fd-602d-4ce0-ad32-211f5e7ca765,"" +805e5d13-6a31-405f-b43d-3449d73a50d3,"" +806085ba-3993-48ca-851b-a5dbe0690926,"" +80aca9f1-6907-4658-b0e4-bf6f53838148,"" +80e8b1f5-ea5b-4abb-9a06-b51bcce673e6,"" +81155341-1ad4-4473-ac14-9257704203e4,"" +8118e76c-1974-471c-9cf9-0b31ed231efd,"" +8131895a-c6f1-4b0c-aba6-cc3a52066646,"" +814970aa-0552-4357-b958-d572f56421ac,"" +8177f823-7335-4da6-aaf9-354e05299d71,false +8197ccde-83c1-4ab3-bf4b-e849667f1f31,"" +81dd2be8-9b50-4d63-bc4c-22c4dcba127e,"" +81f1e8f4-a335-4910-8a27-151141514c39,"" +822dee6c-337f-4a5a-a22b-7de9e64d1144,"" +822e3fd3-ae35-4e89-a5be-feac7c6f62cd,"" +8242d422-fa39-4374-85c7-5d267d68a0a7,"" +826cf99c-9d92-4cef-b717-d5c16ea7525c,"" +82e58dcf-ea72-4a50-9eab-a74460d58e4d,"" +82e8a61e-9eb4-4fce-ad43-881202cdfbef,"" +82f09a48-3b8f-4a2b-9067-61b51d85c500,"" +830df854-5f4b-474e-9aef-e7be6b452a92,"" +832e240d-da2b-4658-b638-cd2cf2f08912,"" +83648485-484e-46b6-9a11-64a48fe471f0,false +836f63ac-40e4-4170-a9f0-f170c4654db8,"" +83b971fa-bf7a-49bc-b1d9-09680e8eeb24,"" +84a15a42-428d-4092-9f54-235b55b11de3,"" +84c41fdc-0d34-4d95-8999-7677e4235e5b,"" +84c90e57-2348-4843-a557-444e3a82ce43,"" +84d36e49-fc69-46a1-a5be-e9842e8e192f,"" +84ed43cd-526c-4055-9422-c31dfefa43ef,"" +84f38578-0070-46e8-809a-65c75623829d,"" +8502fd55-eeba-4c91-8274-4f34dfe89977,"" +857895a5-3a82-45fa-9fc0-00380ef01b47,"" +85827568-1a34-42f7-877a-99a2d3a0f5c8,"" +8591ca33-6c89-4352-adf3-8261ce1bf58e,"" +85ea993c-f6d7-4b7f-836c-3c76206d66c1,"" +8644762e-70c7-45ba-a0fb-92fdb9e6c73b,"" +8668b20d-ed68-4d67-91fe-d35c385a3408,"" +866bd41c-debf-4a53-9108-fd9c0784103c,"" +86786682-7825-48f0-bbc3-3b1a127aa654,"" +86859d13-26a6-429a-a38e-be69f1af9b4d,"" +86946982-ff92-46cf-b6cf-caa45ba4a986,"" +86bc9f92-f89b-4fb1-affd-093a785ac1db,"" +86fee3a6-5135-4265-8c8c-04ac00ea8e12,"" +87061f96-823c-4e0e-9dde-8034682651a8,"" +87346977-9c76-4d76-b8a7-23ded71369a2,"" +8746d3f8-1943-4ab0-af49-f7d40aad5cc9,"" +875be020-8c24-450d-9ddf-f642e60e62f2,"" +87e5046c-332f-4ab2-b8a9-ab15cfa91fa5,"" +88274e29-0d4c-41c2-9315-f96c93d44c0d,"" +886a561a-e64b-44f8-bc77-76724e0c369d,"" +888dfba9-08c4-4048-bb9f-23fe80dfcf5f,"" +88a3a7ea-728e-4bbb-be44-73093e564cce,"" +88aecc11-264c-4a3e-a2b7-94c99d39fde7,"" +88cf49a9-ec8a-461c-87bb-003866a4e28e,"" +88db01b2-8bcd-4671-9447-f466279f21f8,"" +890cdafa-a6ba-47df-9cc6-5ea4d4febcfe,false +893f9661-bc71-4f65-83de-6483e73bbce3,"" +8979e8fc-9f34-4305-80fe-122fc619c7dd,"" +89cefdfd-b6d9-41fa-ab28-50563fe44a74,"" +89da332a-d11f-4f77-977f-6275f337495c,"" +89ee0500-71a0-47c2-a59a-1b681d9a92fb,"" +8a31ea5f-804f-4b8b-8f91-6ac4bea2c4dd,"" +8a56157c-ea64-4f80-81db-0c89a9d0b547,"" +8a5eacbe-4ee5-4e3f-9a0d-d0d1a13ae2ed,"" +8a8432ce-47e9-4fff-b71a-3147ad298fd0,"" +8ab69964-40a4-4d5e-8d2d-82d07174989c,"" +8ad34764-84db-4613-8483-4e8281f8f984,"" +8bbcf675-5176-4df5-bbeb-38603e8d9c42,"" +8bf02dec-bd39-4a1d-b074-e0ef2167b93a,"" +8bfb6668-fc94-4b2d-9ec2-3385f1780d58,"" +8c39345a-45b8-44db-b5f3-6b5914b3fd93,true +8c492ef6-59bb-4ccd-bc64-48d58d3da475,"" +8cda568d-3e48-4e77-afa1-374809ed3c3a,"" +8d671817-97a1-46c9-b23b-e3013f13edb4,"" +8d98567b-2930-47f8-ad39-759745179c38,"" +8dcdbdec-4dd9-4928-9e46-4f46fd6df9dc,"" +8e1303b5-0694-4bc3-a0f1-559d51e05364,"" +8e55e68c-f1ca-468b-b4f7-11c11c2956cd,"" +8e5ebd37-bb67-4c84-b9ec-3422ed7c3b19,"" +8e9c8ff0-82b8-4974-91a7-888dce4f7f8d,"" +8ea94f05-b5b6-4aeb-987a-567f627a4216,"" +8ef5e898-02ca-4617-b966-d5954b2cf403,"" +8f051932-7f43-4faa-b3b4-c2254756c603,"" +8f19178b-b9b8-4858-8f94-c0f1e6eaf2c9,"" +8f5f16b4-fcef-4a03-98c8-a6aecea249f0,"" +8f62568e-7778-4729-a454-369f5a3f12f9,"" +8f62ada0-3878-437b-aeca-d59d658ece1e,"" +8fc9a4e9-9ca1-4144-8cf3-032a5ed6bac2,"" +8fea3b61-246a-4333-ad04-78348cb59585,"" +8ff0c7a4-f1c3-400b-bb31-c66df4866cfc,"" +900405a8-53f2-4a6a-bb75-80e9725f3439,"" +90126aaa-1dde-4136-9be1-4e30e2c1b667,"" +90e6ec4e-bc73-413b-a07a-e8d3b675c027,false +91357869-20f4-4e58-8237-5b028e1f733e,"" +915eb7b9-47d0-4abd-a424-29605ef5f497,"" +91874305-9f9f-44b1-bac3-28dc0fabd0d2,"" +91f7217e-5c7c-4462-9f7a-ad7234bddf6d,"" +929edb45-2558-4fe7-b87b-ad4a801a26eb,"" +92e25da6-dacd-4d0c-9457-751bc135c126,"" +9307ddb3-12ef-414f-beb2-62a145d3f63f,"" +933302fd-1717-4cef-852f-0bc28dcfea35,"" +937de252-6da2-4dae-a80c-8ef39c6eb99b,"" +93851c17-f570-4055-b6bf-ff928624666d,"" +9389f1c7-bba0-4286-ab0e-73ca1430824b,"" +9391e021-6734-4c01-a6d4-a9e151e58201,"" +93c74a74-55b1-4f45-8b7f-3a0442ea5006,"" +93f749e0-9ee0-4cfc-b970-20f1757aa207,"" +94b95bc4-3355-4881-93ed-5db3dbcabc26,"" +94c1cc51-4dc2-4dd2-8a48-b6793675a44c,"" +95accbba-6ae9-4e70-9984-235e7371234c,"" +95ce9659-ea2b-43a9-a6cb-0b85fb4d9a48,false +95e68649-5482-4d3b-bc6d-ca77d83531a6,"" +95f21d98-e820-4054-970e-ab04c6b0ef69,"" +960866ac-7fbe-4f4c-8a41-f5c6d756a394,"" +962aaceb-7115-481d-8496-5ee5d12ac43c,"" +96526997-d779-49ea-999c-43bd07d250e0,true +96a5c8b4-5c9d-4092-9171-03da2422df80,"" +96df629e-35be-42c9-ad60-2fe43dfba0f1,"" +975a8040-5330-47c9-9bb6-13a1d07fd3c9,"" +979229e7-5022-4a8e-9f23-8673564bbf4e,"" +97bd3c96-d38e-4a46-9e9e-0ff3466b80a6,"" +97d8b079-ffd3-4bfe-a1a4-da06038813eb,"" +97f558d6-5624-426b-b21a-6a92c463d004,"" +98216728-4494-43ee-9af2-930201bcf2fc,"" +9873061d-c9e3-48f8-9a27-6a92255869c6,"" +98da112b-cca4-4bfb-9b85-32accfe1d295,"" +98e90113-a97a-40fb-b6e3-dd5f2e646901,"" +993d7bc1-e96f-477f-b7e4-ad8d25c59e94,"" +995d662c-8641-4089-bb52-417a2eaba272,"" +996a443e-1ca6-4e05-b1d8-b84455f2412c,true +99893b11-009f-4ae2-9ce4-c0db476800bb,"" +99929bed-454e-4131-8368-9d152ab1da8a,"" +99b31b91-ec68-4c94-b23f-2b75d9302cea,"" +9a1f1ac4-3ad5-4ada-80b2-cc31176393a6,"" +9ab5ad8c-b789-482b-838b-6cdcbd184330,"" +9acec191-7d26-4519-aac1-b50e00f3a2db,"" +9ad11a61-23e0-4603-90fe-c3001fdc7320,"" +9b4a1f69-52d8-4c2a-9e8c-072f71c2bd18,"" +9b876e7b-aa09-4b8f-8c58-a0cab74580b3,"" +9b9b76e9-88d4-4440-868a-c5b153c277d9,"" +9be9764e-cac0-489a-85e7-9f3c995e7061,"" +9c3ab93c-6424-4402-bd4f-0f0f7dd2b265,"" +9c630f43-c0db-42b7-b223-607d5a9a39a5,"" +9c9cebe1-ea55-48c0-9edf-22033f5ebebd,"" +9cb03b1e-f448-4f94-8c42-7f9271202a1c,"" +9cc11154-43fe-4bbc-a9ee-c5b8e0158d51,false +9cece101-e41b-4d77-be20-ae0c0cd2cb9f,"" +9d3c20e2-321f-488d-9472-5756fa061ca0,"" +9d415448-4c3d-40c3-b910-ee3ff0df9b3c,"" +9d495d7d-837a-4d3b-bb10-608f9abc919e,"" +9ddbf3cc-7d54-4532-a670-5c361df676d4,"" +9ddc0101-8632-4103-a12b-bf8c5590f624,"" +9deb306d-e6ef-4bdb-9a20-c9f5ebc556d5,"" +9e1b3c33-ef02-48ce-9b60-15b62a9a499e,"" +9e32e6c5-44d7-45b2-bb87-65e98f8464b0,"" +9e3fc42d-d08c-4cb4-93a0-a567c5f6a19f,"" +9e5071df-d3ea-4bd0-83b7-e08ba3fbb896,"" +9e58de28-a944-4ca2-b53b-b8da836ebd93,"" +9ea9ede3-8f0d-43c0-9f35-cc9fcfb622e3,false +9eac5165-a8e6-4acf-8d52-4ad49e2ba851,"" +9ed868fd-baf3-490d-b665-113b9427520d,"" +9f078010-f724-422a-8d8c-8855f2513eec,"" +9f3630e5-1b35-43bb-b53f-c191634ba14b,"" +9fa9a6d4-e6fe-4eba-bbe4-7319b735c63b,"" +a0238799-d0f0-49a9-96b4-33cfc1688279,"" +a0520e0d-7dc2-4218-9176-32eb842de85f,"" +a05480c6-8b4a-4406-9226-8dce4bbb4d21,"" +a0eff999-b331-46a2-b8dc-16727efc7580,"" +a0f58ee1-6e61-41a9-b0c7-5acdb005ac0d,"" +a1007ed7-d907-443d-813a-0bbb0ed84e50,"" +a1155987-73aa-4d48-b127-5da6d4cb7b02,"" +a1bd990a-7d22-47af-8258-5d4a05b269a6,"" +a1e0979c-d57c-4482-9087-88077cf657f9,"" +a2224a99-ae98-4018-8651-38f1f145c76b,"" +a2466ef3-db84-4434-9e07-af11c15c7490,"" +a253f260-5b6f-40a2-b4cc-d2c66856ffcb,"" +a27b5fe8-3465-4b6f-b63d-cca66626727f,"" +a28cbadf-918a-4831-be0e-9ab6c83133d7,"" +a2a6355a-2c94-4da3-a707-cc6db6553ce2,"" +a2bf4c9c-46d8-41c4-8eb3-044e832c78c6,"" +a2cb445a-10da-4b47-add1-16584c34d8e3,"" +a3240817-7453-496f-9d7b-058889858399,"" +a34042e1-cc97-476e-8564-382d941458b4,"" +a35cdf18-7bae-4776-8aaa-652bfc135af9,"" +a3b8ad3e-c982-4023-8977-e9717a33d645,true +a3f4de14-3398-4b34-9165-3a24c5742de1,"" +a3f9fe69-1527-4d04-a51d-ca9f1955d210,"" +a452f6e1-013f-4745-aa25-e2cd16ca4423,"" +a46ec80d-9cd6-49d6-863c-5f5425899445,"" +a49f38eb-8de7-49e1-b7de-97ab32fb277e,"" +a4b245ca-a50f-4bb2-ad64-1124c31eb166,"" +a4d85c0a-4687-4454-89be-085b9a2632f9,"" +a4fec49a-dc46-496d-86a7-5387c2490c3b,"" +a500b66b-fab5-4ee9-bda7-11fb6170fff0,"" +a533451e-9e8e-448e-bc5c-1beace2c397c,"" +a5a464c0-3b64-4ccc-bdb4-62aac198eddc,"" +a5c68c36-129c-482e-a9eb-023d7ec1ef0d,"" +a5d76237-0ea6-4016-91a1-33463ef1e9e4,"" +a60eddcd-ef19-4a84-ac8f-9206ed2aeed0,"" +a618792b-5b12-4545-a3e7-c07313d188f3,"" +a65e37e5-cf18-488e-8870-e4aeb021ee41,"" +a674a795-2553-478c-a5e4-6fbde13d7523,"" +a67aa655-62ae-4905-8042-30fd3ea68944,"" +a6a1fe2b-4322-4ea8-9ca9-3bcf288afe36,"" +a6d86605-7084-4477-8c8a-8cf25c4d1b9b,"" +a6fbb09b-5b17-49f7-a510-5c1596b424a3,"" +a717a4a4-b0b2-4aba-af9d-7b431e7883e2,"" +a71de636-d8aa-4455-ac06-932ae6d848ee,"" +a7575150-4148-4b9c-b941-64db8cc61356,true +a769b6ce-379a-4f6d-ad06-5df3a58d25ff,"" +a7a4ad54-167b-4cc8-8f88-dcb555c9dfb4,"" +a7b38940-3cd3-43b1-bba9-6adb6090d1d3,true +a82170ad-dc53-4899-a7ee-cdbb50e6a91e,"" +a83fed45-f814-46b9-9fdb-50892a1a1736,"" +a8624bea-ae5f-4fd8-b6ed-11b0fbba9254,"" +a863d462-6836-4f42-a4a7-8925574b76fd,"" +a8c9520b-bfa8-4915-bd66-a6133e1c5ffe,"" +a8f862f6-2e8b-4cec-81ab-eb3be51d71a8,false +a906f033-5f9b-4c1e-aaff-287cffc6cc7f,"" +a93d01a3-5bc6-40c2-9895-64a21fbd6253,"" +a9584e1e-deb8-45f9-830c-bef1caeb21c8,"" +a961ce1f-cf0e-42f7-ada6-f283daeac650,"" +a972425d-8c4b-48ab-ae2e-fc7db6661f67,"" +a9888a76-f2fd-4161-9d15-6126ba398899,"" +a9b103bc-f890-4d91-9714-8d674aa842fa,false +aa5fe96b-324a-4010-b128-a5063ce0be77,"" +aa86bd26-a862-4a03-9d8c-a04ec4c70c0e,"" +aaada565-8a59-4f69-b92a-a6cd9a323a24,"" +ab3e98bd-050f-4bfa-b6e9-d829291290a0,"" +ab50086c-5cac-4c6b-8e71-6988453228aa,"" +ab52bac3-d430-4700-b1e6-7efe2f5613da,"" +ab63c859-8b0c-4874-9404-cf7c89a368e8,"" +ab8aa7ee-f65c-4a29-9995-ef33c4135035,"" +abcfc7ff-d824-4414-a586-3c33c263a990,"" +ac139e4b-9d46-460e-92d6-0ac43ce8cb67,false +ac5bafbf-2bfe-4dc4-8e13-adb2d80e8dee,"" +ac645c40-0c51-4d77-a5fd-32e619019c60,"" +accb0b6f-b012-42cd-9374-91355ed49aa8,"" +acd3b2a0-1a81-4738-9bbc-9ab0c56b0a85,false +acd69c03-a3c4-44fa-b3d6-749476309db9,"" +ace8301d-b547-4cb2-8311-e27a8980633a,"" +ad07d661-6987-4928-93a0-e7b902b24ffd,"" +ad2a1d8e-6e19-4d5b-90a7-ab24050735a2,"" +ad48d6a7-890b-4eba-919c-ff6b63e35304,"" +adad08de-aeef-42cc-9a2d-b99fab5ab1dd,"" +adbb15f3-b71e-49a7-a954-2f117a93b972,"" +ade38b82-c9cd-4a9c-a7f6-23130baac87e,"" +ae13da32-7194-4f04-9fd5-c7f114a2e5b0,"" +ae4da701-069d-4ede-b59f-a2524c6529f0,"" +ae52de8a-deeb-4144-bfd3-52c2cab5fbb0,"" +ae56f2bc-f7f6-4bc3-ad8a-3b1193e40f71,"" +aea61272-bb6b-4fab-9817-584a8fa2f55b,"" +aec815b1-23cf-4504-8576-fe03b8798092,"" +aee86188-c252-4910-98cf-a8d3ca9d029a,"" +aef2f04d-7449-4088-9ab5-a227d1d7c36d,"" +aef45e8a-6923-4db5-9bb0-18f472f7f0ee,"" +af12db23-5b03-4e68-9127-acc14775690a,"" +af52f728-fcd9-464a-9e25-28013b84fa1f,"" +af73e4bf-2ba0-44ec-b619-a04f1c13c9a1,"" +af77032e-b1e1-42c5-8540-68bcb906f134,"" +afd2cfb1-57b0-44ab-a8f5-6edc92bc870b,"" +b0138fc8-736a-433d-831b-0bc39281d67d,"" +b0525467-772d-4d5f-b326-095fe72890e9,"" +b07bd4e7-6586-49d4-9f43-19d58889743f,"" +b0a1b45a-9dfb-482b-96d4-362cd1ee625a,"" +b0a510f8-2c98-436d-841a-eee086eba241,"" +b0ad5c48-9538-493c-b5a7-87f8f5ff858a,"" +b0b8b0c1-8184-401e-9346-37422a6f2f81,"" +b0d0e0b3-acc5-4887-a39e-df765111f99c,"" +b0e1d515-5be7-409a-8c86-3aab8ab6787a,"" +b101ebeb-ddbc-4bb2-b5c9-2bc6a23e0a16,"" +b109fc82-447e-4d4a-a447-1c7f0569bbc9,"" +b12f7f41-f8f8-4eb6-b2fa-dd5a18639c11,"" +b155b9d3-54b8-4906-a564-601bf123f027,"" +b18674a0-77ec-4d7a-b563-aad0856ce45e,false +b2071f60-d582-424d-b873-9ea4c2615442,"" +b217ba96-19d5-4184-a1ce-890bfdec478a,"" +b243e613-8498-427d-bc20-acc54786ed44,"" +b2503fbd-507b-44db-b4d0-32700a3ba5f5,"" +b260cc9d-644b-4e25-a99e-9afc44dc3879,"" +b2766451-0904-4ccb-90c3-fa7fcdbe19c4,"" +b2b2289a-0762-4846-a4a9-fbd7dc1a3822,"" +b2f8bfb5-d8a4-4df9-8724-bbce63e4dcdb,"" +b3394219-debb-4c75-988e-98fef99f0500,"" +b34ef85b-d2fd-4fbd-bb2f-6c21d737e21a,"" +b376a344-8079-4b95-99a9-d515f9dfa4a3,"" +b379efa9-29ce-44ad-b653-9cc03ac2bfe6,"" +b3861c55-ae00-4319-8a76-03627b8c8bf4,"" +b42a782d-79e6-4276-9fa8-744d5d1bea24,"" +b444d377-d1b0-4eb3-aca4-c24d3fac8c37,"" +b4771fd0-758c-413d-bbc2-17e8e2cc79bd,true +b48e7fa4-1922-4d4b-858f-a4f3bd8810a0,"" +b4a9bcfc-73ae-4798-a221-bbfe9991e0f0,"" +b4ce60ee-7591-48eb-81ec-0466d931b2a1,"" +b4f80b37-afaa-4974-9cd7-f53d788b2be0,"" +b508dc50-ca89-4b92-a12b-b032d3bf3a5f,"" +b516b7eb-4029-454b-a8ec-9bdede40ffb7,"" +b55a959a-73e0-4b7c-bb03-88bb22844c09,"" +b59c5c8e-7d5f-48bf-b3d8-900e18a64b12,"" +b67c717e-f9fc-4ec3-8cdc-ade1c8d1b95f,"" +b6d48a75-7d74-45e6-9fb0-154ca5264744,"" +b6ed4e6f-6911-4cd5-92de-f50e8d1916e4,"" +b7289502-ed78-469e-8b73-04811493a484,"" +b7597773-8d3f-4ee7-b54a-6c8b60b6d47a,"" +b762619c-c328-4367-99a9-41f10751cedf,"" +b7d87d24-1805-4a12-8f8d-2d14509d5eab,"" +b7f806c7-6ed8-4b7c-bf42-dae336e3f7b3,"" +b80e31af-6b74-4685-a83e-50c5d7f762fe,"" +b862117b-c899-4938-9df3-6baf43911d1b,"" +b89dd640-c21c-413c-8774-f9a154d897f8,"" +b9578448-2338-4f49-9d63-5b886a537f07,"" +b9701217-a4ec-4ef4-84f8-49ae5825b45f,"" +b97f2f71-17ed-4e3b-8e3c-374241e6faa6,"" +b982af8c-9e7b-4dba-ba74-76770efffefe,"" +b98be876-6fcc-41e8-ad4f-a78b1661acb1,"" +b9dc5e38-47af-4d07-8ad1-b0425c5cb386,"" +ba047f08-841c-4d5c-8f98-b3e614906d17,"" +ba5a0e2c-6e96-44d3-800a-991a81337994,"" +ba7bf8c1-e6a4-4437-b1ef-cf9e443971d0,"" +babdc581-4c93-4674-8743-1be4b18ba156,"" +bb182025-e149-489f-b69f-debf6907da09,"" +bb2c53fc-6d97-4747-a60b-8010f62b7f63,"" +bb770b6e-11d2-457f-858e-2e2c6c86c0bf,"" +bb94d817-e843-416a-bc31-4858001e7976,"" +bb9c95de-6073-4239-bb5d-023d18344157,"" +bbcd2900-31df-492c-9d43-e8e0243f7e1b,"" +bbe0b9ec-5a6a-44a9-9770-fbe4117593da,"" +bbf5580d-bef6-4cd7-a231-b6a532d68aed,"" +bc1bab6f-5d84-4c95-afa7-b4ab39038ced,"" +bc23a56d-f42d-4bdd-b704-07376d4a24af,"" +bc6abddc-4fa4-4ae8-97f4-9c566558b227,"" +bc75ec01-01c4-463d-b64b-597c106d4eac,"" +bc929bf3-06ac-408b-a17f-6ecdb28759a7,"" +bca14431-d108-4ceb-831b-b6cedb7b1b22,"" +bca1f5dd-414a-4570-9f0f-ed733bd170f6,"" +bcec2bc4-4e04-48cf-b52c-8e1fa2ac3875,"" +bcf5154c-180c-4366-836d-13aa6bfce980,"" +bd3b7896-2b3e-4c1a-a2b0-aca1c2ea23c1,"" +bd687828-857d-440d-836e-5230d3254b1c,"" +bddfe37f-fb3f-4a24-9ce9-181f250aa0b8,"" +bde29534-91ef-4817-a1f0-00a5cc9475bd,"" +be196f96-4e26-4c23-8241-b0a10a39e831,false +be1ca606-c535-4751-b52e-c61cfe9b6c73,"" +be3057cb-9635-4a25-863f-b4e79cda75c3,"" +be6d80a5-e2df-4e99-9721-80097129bd8c,"" +be7a093e-d70a-4a23-9db3-bd95aca334a6,"" +beee46de-ddd6-4fe4-80bc-6f1f4b8fd42a,"" +bef4846a-ca76-4000-a98a-00a9d327107d,"" +bf88c593-87b8-46d5-808e-8a332c5b50d5,"" +c015fb2e-4062-417d-86be-681d98f8a13b,"" +c0381889-4401-4bc4-9056-641340fa7ec9,"" +c070e6de-9ae3-42fc-9cf3-023839ad0442,"" +c086a87e-ec86-403c-8bc6-37a9b77924f0,"" +c095cfbf-cd84-4681-ba67-7b3ed318186b,"" +c0a2c5cd-58d4-49ca-baa7-d5859abc680b,"" +c1003a14-56be-43d0-9aed-41fb6b048273,"" +c1370f98-3833-49d3-b58a-21c581ac4ab2,"" +c14127c7-9943-471c-b5c8-ee9f0bb95bd7,"" +c1d430d5-32b8-4410-a1b5-6212b2c411ec,"" +c2253c94-aa7a-4e88-8410-e528b08654f2,"" +c24b807b-174b-4e5f-91d2-93599fb21548,"" +c25d3d58-1f6d-4004-85c4-3a162dbf48ec,"" +c286cd77-3c89-446c-a91a-4769aa088be1,"" +c297cce1-5d10-48da-8ef9-e860ac55f387,"" +c2a32eca-f03c-4fe3-8c29-3b69c9798b5a,"" +c34d92cb-7086-40e9-b303-97e204d2ab4a,"" +c36767f9-a3d8-4f57-a370-4a088ea0b023,"" +c37a2b82-a495-4d05-8f8b-99a757d0b83d,"" +c391f109-1259-47f6-979b-e72492709b66,"" +c3aaa4df-ead6-4a84-982d-3c28752e1070,"" +c3ab4714-5eda-433e-b461-c1710b769476,"" +c3de8ca9-c03a-4689-8701-dd524884b5b5,"" +c3e98495-15f0-4040-b92c-31aa40235dcf,"" +c47474bb-570e-45af-ad38-8f5352ee3774,"" +c4757dc4-d69a-4e2b-9b8d-61353a5b21e7,"" +c4e0ccb4-df43-4b20-873d-3a66faab42b1,"" +c4e31ea7-6ad0-42b7-8579-c3b7fcafa740,"" +c4e6e6bd-2135-47e8-81ae-7e1d6d5e7482,"" +c4f82d4f-f53a-4d32-bc78-67aa7786ed1e,"" +c52dbae3-07a4-4039-b04e-d79a86941c76,"" +c52de404-7bbd-4b07-95a0-a66df22a3221,"" +c533b9cd-e56b-4e32-93b2-1189f37eb646,"" +c557b460-3e1e-4ec4-9b4d-ea7bc0c8d64c,false +c5609af5-9f49-49f1-80ac-b18fccbc9720,"" +c5f20b88-cbd1-4283-ad46-5b0bf31fa3ba,"" +c6386600-4824-43b9-b366-4504f4e74d66,"" +c6442145-3aad-4b57-b2cb-b7eff0699959,"" +c6700fda-f009-496e-83ec-0532f34bfa92,"" +c6a0f008-4d97-4319-8099-7e0cb6708438,"" +c6a3be9a-b061-4a5f-879c-e948aa895f3a,"" +c6b44473-ebbc-48dc-8a42-44b7da0de840,"" +c6cb9c06-0c13-4cd7-8d20-ca7b99f7d141,"" +c761f0d9-c918-41b3-9131-856aad1f5b2b,"" +c7e313a6-4659-4fad-9402-946879a91616,"" +c7f263ed-22de-479e-909b-f6ceaf5f2eb0,"" +c80ab964-cf3d-4e89-9232-8e787cb0def5,"" +c80ec189-5f9e-4049-922e-969d28b3bdde,"" +c837974e-0093-438d-a822-19e97249f0dd,"" +c895019e-6471-423d-ba15-4f06ed628c7f,"" +c8bbf035-8a01-4c57-934e-988a584c98b9,"" +c8c936bd-3e6e-4500-bbd5-051659c59309,"" +c8cb1ae0-6a31-4869-a396-78dd5dc7f302,"" +c8f123b5-8e57-4c9a-8770-bd4b4c2c064a,"" +c8fd40e1-35fe-4c8b-af6b-730fd6fb5fab,"" +c92a4616-7215-4ba1-99df-40aea82eedc3,"" +c9445880-656a-4def-ad1b-2a4200d76c13,"" +c9647fa4-976a-4d9f-9be4-26b9c71f6eb1,"" +c98372ea-e9ae-4438-8715-b54ccdcc8f30,"" +c99c2510-b392-42ee-97e1-16f6a3b50978,"" +c9cd4daa-907f-490d-b3e5-a43eedd74c32,"" +ca45fe64-e7c9-48ea-bc02-3bc6a0b58e46,"" +cab21bd5-4314-4bb1-8b16-0967f8b08757,"" +cab53124-f25d-4b4a-a238-3d028e788b2e,"" +cac06963-2da1-4935-a6c3-d6152132c7eb,"" +cad24afe-7131-4158-9153-742c9fd16c9b,"" +cb1c6a1f-e659-4fe2-9cfd-f28e776a4f06,"" +cb5c302b-35a6-4d8d-8d6f-72ad1a3ed1cd,"" +cba58256-d558-48df-83d7-be5939d6dfab,"" +cbafa157-0905-418d-983e-827cc88faa94,"" +cbfd98df-8ac2-4497-988b-bc4d1c9c6095,false +cc0b8f72-76dd-4eaa-84c1-c343982e18e2,"" +cc1e584e-6752-4bf3-8c51-ac0192b5df44,"" +cc372f1d-a83f-438e-8d8e-c346eb03fee6,"" +cc38b529-3137-4d89-804e-51c6bd60ca97,"" +cc3a3e25-87b0-4012-869b-9905b31f8319,"" +cc5fd0ac-6ce5-43a6-bb4a-67279156ee8c,"" +cc7e521d-4fa6-4215-942a-48f84ddf9a49,"" +cc8ade38-d9f1-4700-aad3-dc866f35d1a1,"" +cca1c9e8-c68f-4fe0-ae79-693399d8ee31,"" +ccb56a74-40db-4d58-b0c4-cd485e8a7fe8,"" +ccb810a0-28a5-4248-92dd-7259a0fa0c22,"" +ccbda4c9-3ec5-46c1-a8d6-a215651dfb43,"" +ccbda933-c3d4-44bc-acfc-fd26bc234bb6,"" +ccd5afad-8f2f-4305-b646-26137eff0a0d,"" +ccd69a01-cd72-41e7-87b9-de8454411ee3,"" +cce63ba1-abd2-45d1-9ba0-a2cd0fa9b00e,"" +cce6dbc6-3a49-4f8c-b908-e6f11be81ac6,"" +ccf36cc5-5009-4fbc-8e8e-81f38d3195a7,"" +cd013d11-8609-41d9-a9c6-7fb33a499f51,"" +cd09f5d3-c846-41e7-a1ff-aabb55973663,"" +cd2c3f78-ddb1-45f7-9939-987e070d9414,"" +cd3d18de-96d3-4132-ae73-b80795a53ad0,"" +cd71ffde-9d7e-4c27-bc22-306f81cb46b7,"" +cdc96f77-a589-4ae4-85b6-c6d2c89487ba,"" +cdcad0ef-8049-41c2-a8ee-21835323b05d,"" +cdcae470-3531-4548-a2a9-ba665fca8930,"" +cdfbf7e0-ad10-4c22-9ee4-888bb6bdd198,"" +ce1b7543-fee6-4267-a00d-daa5a5ea2861,"" +ce225925-36ec-4c1c-a327-c64a146bef46,"" +ce512c4f-3808-4ef6-9853-6f7d14e146f9,"" +ce7037fc-2614-46f4-a8db-40a2a0f9e3ac,"" +cea2e600-da22-42b8-aa08-f0e951ff35d5,"" +ceea3ce9-5ab6-4cbe-99b2-34ca9e6eb468,"" +cf17f19b-9f66-4391-bd2c-55384690d9bf,"" +cfced5ea-1e8e-4c85-8318-ef91a041f4e0,"" +cfff2bee-7cf4-459f-8690-3638266a07e3,"" +d000b381-5ba8-4a5b-84c7-f371e104eeaa,"" +d012051d-65bd-4a59-b4cd-f454d6010888,"" +d05fad91-9a3d-4d8b-ba99-5a33fcc82081,"" +d083a1aa-9662-482a-8192-4709f904f16f,"" +d0b22c1a-d0f6-4d83-bd3c-475a3acb0b83,"" +d0be6a2c-ebc5-405a-a2a5-006a5ea52c76,"" +d15e2267-a699-4f43-96a3-e98de7ace044,"" +d168f31c-483c-4340-a2f4-6a60cc8cab30,"" +d17dfd97-60aa-4313-bcd7-f48935faa2e8,"" +d19385b9-bc04-4000-bddf-1d09425a2b4f,"" +d1ba146a-9503-472e-b668-3686ff275ef2,false +d1c2f4a3-8af5-4ad4-bd0c-032b947d3c25,"" +d21af0cb-c5a1-401d-b605-a2e3ba3f46a1,"" +d2272949-75dd-4949-88fc-f0f157c83105,"" +d230ce54-d5fe-4983-9e91-519ce1249322,"" +d241d156-478f-47a0-989a-96a5fff36780,"" +d2663716-cdce-4d88-90f8-51fb5d59aa4d,"" +d2a3d703-44e0-4dee-a8bf-9fc0457841ae,"" +d2c11b5d-93c6-4500-bc4c-8dc50057f362,"" +d2c4f328-e7a4-4d87-b180-9a0eee13d165,"" +d2d08017-f955-4e0e-baf0-2d5d37acc304,"" +d31bee09-f02b-44c5-aa15-a06343e0bf9f,"" +d355c55f-53b5-407e-8785-33e4e54bb3fe,"" +d37a07ee-5d7b-41d0-bbf1-331277662c52,"" +d397d6be-6008-47bb-9f72-628fb5c41cb1,"" +d3997124-9e16-4df3-8c60-f43f62bbf036,"" +d3e6de0a-bfef-438a-b982-4818145651b9,"" +d3f2c0c5-1f4c-4156-8cc0-e2d87db500ea,"" +d44741c1-d58a-495e-9f30-cc0f19fafc4f,"" +d46e0f9c-5dd1-4e88-9a22-96ca436674d3,"" +d4aa494b-3328-48fa-9873-39be6536a437,"" +d4dc8d84-20e2-4053-b244-47549e74680c,"" +d524b58b-90df-4d29-b4c8-308ac04dda2b,"" +d56569d3-0a16-4968-9470-93d410916f11,"" +d5944a91-3bf9-4915-8512-0f1f50a8eb7c,"" +d5aa4b50-1ac3-48bc-90ee-7ad6bd78a078,"" +d5ca4448-871c-4175-801f-38bb43cdb48d,"" +d60c26c8-1b83-4de9-be17-81fca1ef2575,"" +d6c622c5-3662-4b29-9180-0b4055afa612,true +d6f1073c-bf1c-4232-8ee2-5b92f0a32d8e,"" +d702593f-4121-4ac3-bc3f-dae097c7a044,"" +d702f666-bb61-4d55-9579-e56efc3e0e91,"" +d704d649-9e08-4502-a9c5-820f503dac9a,"" +d7c0876e-3031-4be6-aa2b-bbd8e2bd8884,"" +d7eba5f5-103c-4442-9a7f-62c81a9dd9e5,"" +d7f76663-5195-4de4-bc43-ee61e467fee4,"" +d8534558-7fea-4dcb-a1fb-2981b725dd61,"" +d86d32ef-f50e-46d6-b434-fd03bc807cc4,"" +d8a42c84-6930-4b12-8c1f-9a492d290454,"" +d8cdd01f-c8b2-46fc-8f69-35da565e1b99,"" +d909c299-c622-4c39-829f-415621e09eb1,"" +d94160a6-7943-496d-8b66-172e9ec6804e,"" +d97e5072-19d7-49bb-aaf1-f3a56816f3e3,"" +d9e59fa9-630b-4d97-aa71-4e03bd6fe1ad,"" +d9ebe2d3-2a6e-4079-8f59-43a327e68ebf,"" +d9fb7469-d50c-4492-8c1c-8bac1ccf81bd,"" +da33cd96-8f15-47f1-aeaa-846234a6b9cd,"" +da412e67-cea6-4ad9-8c66-75bf7bd9d0f9,"" +da438390-6d67-444a-be2e-354a21d30559,"" +da4c7a8d-c75b-4050-bbac-5edb50e48d4e,"" +da5de060-6e29-4379-9119-175b394f9bac,"" +da98f3f0-236f-4c41-b123-09f1fdb5bfc6,"" +daa0c0a8-91bc-41c5-9627-adad04a7b15b,"" +dabbe6e8-3692-406f-8a2d-f81217eb6964,"" +dac01aa1-44bc-4ff5-b123-4868f8f278ef,"" +dac87128-5796-449e-85ea-2c1f8e09ba0b,"" +dad4c0b8-0e02-470c-b7be-6477008d925f,"" +dae5b7a2-ad95-411c-9721-067d3c578262,"" +dae62ac4-666c-48f7-8587-ff9330a9e9e6,false +dafa1e16-2149-4e76-a693-88d2e7e29a0a,"" +db0a2a90-dc62-4e6e-9a46-88b9a3145ab8,"" +db16da7a-538a-4270-bd0e-1b4398a922a6,"" +db1788c0-f515-419f-ada6-834a37168001,"" +db17c5e1-6d1e-4b0b-a345-8dca770e7097,false +db5a6739-388b-453c-99d0-58cfce24d5d5,"" +db8a9775-faff-49c4-8b35-74e92245f439,"" +dba78a31-21c5-4600-b18e-3e90237ab40b,"" +dbbc9b03-4d76-4118-8637-185659ce2adb,"" +dbc0cb40-5e33-468e-bc9e-2cf8ed602d01,"" +dc2a8c49-ac89-487f-a22c-dc126a5c7ed1,"" +dc36732e-8054-4d6b-a860-e7c54f04a0bf,"" +dc567aee-5073-493e-bec1-b6b0f4e160d5,"" +dca15405-893d-4468-84ad-574e54f45c22,"" +dca8db58-f563-4a61-b747-94f5ec5bf135,"" +dd09736a-85a6-4c2c-979b-f2a7027308d1,"" +dd9a2411-d45c-4385-a6cc-650df658ae9e,"" +ddccfc35-d71d-4e65-afd3-4cf2a21e607f,"" +ddda9bf7-d645-40a2-8aed-eb9efa425d01,"" +de1c574a-a49c-41d2-b321-849c005c89e0,"" +de81cdd8-a6ed-4ed7-af7b-6ee027d0d5cf,"" +de9bffc9-c6ee-4ad2-8055-1e0d0e48887d,"" +dea4f32f-0f51-4bf0-af67-e79b34674fac,false +dee72459-d0ba-4771-af17-f38f8396adb0,"" +deee1173-4f31-4784-8c63-d02e2a7b16ba,"" +df471b44-cfeb-43fe-9488-8f85a03952fa,true +df529c86-f229-404c-8f0c-44e1b29e4e95,"" +df54eb2c-59c6-46cf-9cc0-201e94acc07d,"" +df6522a8-552f-4ba1-906c-139f58a0a85e,"" +df8a0f98-893b-400b-9da4-2514e50c0b24,"" +dfa10a30-82d4-433b-9df5-b0d2291378ae,"" +dfa72495-2737-4fe8-9fcb-c799ab51ddcb,"" +dfb67b9c-64b1-422f-887e-139a8f676fa4,"" +dfb6cb62-17e3-416b-9214-6ae6f432874a,"" +dfef1286-acc9-44ee-a736-b9676812235b,"" +dffc6fbb-8592-4f0a-8190-1e64eb2bc634,"" +e0010996-fa96-46be-9431-ebbe139c081c,"" +e00ec480-db7a-4aab-84ab-7e5e7184bfdc,"" +e0ef5017-54ab-469b-9871-f706d4899465,"" +e0f2d024-4210-4f18-82ce-51755627e13f,"" +e1309aae-d59f-44f0-b630-fc538bab9027,"" +e134ed0a-49e0-4a0d-b09b-4e874f422e60,"" +e16400e0-a6e6-459a-a16d-361a7b2ffd1d,"" +e1a9f42d-103d-4e01-b98a-e70f98aa1c00,"" +e1c6ba82-6bc7-4f15-b71c-c669cb78bcc9,"" +e1e4e2e8-1c7b-4c67-bc7a-3940e6670357,"" +e1f9bb17-3719-45d6-b4bd-3be88f17e429,"" +e1faaf81-1761-4a4f-b01d-c179db8474f3,"" +e20067e7-f2fb-472b-811a-3d28a08bf31d,"" +e2501541-dbeb-4e28-b4d8-598e963d6158,"" +e2b04908-769e-4916-bbc4-45ad7db85e02,"" +e2eccb3c-0755-49c8-8e82-cc510481ed04,"" +e2fbc85e-dbc4-422e-9a11-0007d5c194ae,"" +e3784666-7f48-455f-a137-e6262a617ccf,"" +e3c2c69c-bbe5-4678-aa6c-3e5c7ff996f2,"" +e3c5df86-3d35-4dd8-a081-48632a3b67c8,"" +e3c94ca7-a487-468d-83f2-8068a592a774,"" +e3e4b2a1-6c40-4f42-a5b5-17b352209b40,"" +e47d814f-5139-4339-a710-fe953efcfa74,"" +e484c47e-4da7-425b-a636-de512fcbc822,"" +e50c31e2-5d52-4d45-9b8f-8ae3fdd26488,"" +e53c4c4c-976f-4cb9-95af-fb11c264cb72,"" +e53ec08c-9029-4b50-bc1b-a302878b17e6,"" +e562454d-7fbe-43a2-8046-bfc5b6ab043b,"" +e5803192-2273-43bf-8acc-945cc13af70f,"" +e5c7eb1c-238e-4bf8-82bb-205c383f1517,"" +e5d9ff02-57a4-4e05-b573-0dbc80e19958,"" +e5fa00b8-1779-467d-b881-757b6796d8b1,"" +e5ffe973-b166-4240-b5d5-17eaad746c4d,"" +e6e9da2c-7684-41fb-9123-def8a7cb4dba,"" +e7098f3c-9dec-4aa9-9554-b3ad9a7d842a,"" +e73f4c39-965c-47ca-adb5-0544e20d45bc,"" +e757ee7c-a50b-4575-b383-587e6f782bed,"" +e780a3b4-6b8a-40a1-a9ba-5f95725399ea,"" +e78c789e-7b81-49ea-b7e7-d17d8e8925aa,"" +e79745a2-654a-46d6-a886-dd1d21acccf4,"" +e7b3ee1d-2d5e-4dd6-8ae0-ebddf36aee4d,"" +e7d53c39-4adb-441d-a4e1-50c5f60fd3ef,"" +e81ec213-328e-446b-9c33-ee80bc850d44,"" +e83d90d6-c694-47fc-8120-e91546fdda8c,"" +e8ba3683-aa88-4800-a248-737d39ecb6c6,"" +e8f05409-642b-419f-8475-28449c5f9569,"" +e952a654-0605-409f-ac45-19d00d4b53c5,"" +e97e9781-3cb3-44b0-89a9-b704d456fcc2,"" +e9ab227b-2a64-4c48-a8a0-6c166bf4b970,"" +ea2f0657-1625-414b-9c7c-bd0b01a12eff,"" +ea91b2ad-37c8-4a4c-9178-11d7a5e4e75f,"" +eac7851d-1d61-4a35-9f08-c5da53335f7f,false +eace08fa-4018-40fa-a7fc-3daf10b2f21d,"" +eae386dd-ef2b-4629-817f-6f8c44ce5817,"" +eb2419c3-3b91-4d73-b4be-a40e759ab957,"" +eb2781af-72a5-4760-a9a7-20d212f56230,"" +eb511148-31f2-4292-a83f-d16d3be6631e,"" +eba22453-8605-43d3-81f4-f703e58a230d,"" +ebad9165-a532-4846-aff7-5038cd5c694f,"" +ec3d7e48-c9f4-4f64-ada9-7e2891a62d1b,"" +ec462f5c-2aaf-45fa-8c25-6f556349af00,"" +ec4d4a14-0934-4d28-ad20-64db8fe78d42,"" +ec9ccc2d-1e6d-4ebc-b1e5-86d493d19eb4,"" +ed352845-d1af-40f9-afca-53503a6518d8,"" +ed7a65e1-de6f-4c2f-bd47-aa78d0c2189c,"" +edd41c4a-a5f3-4531-b506-d81c04e1ebc6,"" +ee004b78-c05d-4c34-a9f3-290a9259d3a3,false +ee6749cf-0622-4376-958c-229ebc0f9618,"" +ee8905ec-84b9-4fa0-b1b5-0908206b7af9,"" +eeaa2e25-739d-443e-ae83-b0ef04e2836f,false +eed7cb9f-7fe4-4f9d-bb4d-cdaeea6e144f,"" +eeeed70d-3cc8-4b11-9f6e-ab44da414b90,"" +ef079a39-9f59-4681-91fa-3d745c5eaec1,"" +ef10cf22-bdb9-44b5-bc9e-bb777ad8f090,"" +ef1c5dab-b3a9-444b-b825-8fe3d0248e02,"" +ef9360c1-b9b4-4dd9-86de-f996cd22e7a1,"" +efbe6910-0629-46d6-bcfb-5880a1795742,"" +eff17621-813f-4e99-a307-118ac9273efc,"" +f018a615-d5ff-4c3e-84f8-d4ebb1f342bc,true +f04f4b77-a9f2-4ce1-9d0d-6b43d39483f7,"" +f07f7d83-1fe3-4da4-9c33-86aae3ac67e5,"" +f08704a2-c1f5-44d5-a3f6-43c5608dc987,"" +f0a81ab6-10ea-4859-a064-b3b0dc662f24,"" +f177f59d-ecf0-41a6-b81b-a311eb760976,"" +f1a1aa8c-3779-4c42-8302-6006dcb95151,true +f1b36b35-1bd3-4328-aea9-4c5b3a7c7404,"" +f226c31e-37f4-4a4a-aa1f-aa400447a799,"" +f22fe03d-e1e9-40d5-9ff7-a5bb6e7a2d71,"" +f27187d5-f8f0-4188-ae0c-f77ca494a9b3,"" +f27a59e9-c785-47d7-88a4-de7706bb4f92,"" +f28962fb-0214-4664-b9c3-7c67d4eb2e8d,"" +f29f4e3c-81f9-49b1-bc52-47a60a3076bb,"" +f2fd6221-529b-42ca-a060-30db0996a398,"" +f3047ad3-3524-4a48-a00f-603a65fa0891,"" +f310aaca-1c10-41fc-ac49-8430c4c23656,"" +f314d140-929d-4ced-bbd9-c7f0204e99eb,"" +f32094e2-ab74-4567-98c7-e35fe529393a,"" +f3338731-d7b9-4c1f-8e3d-e73b5b756c7b,"" +f3deb81d-79ca-4176-9b6d-bd96bb5b7a16,"" +f3e99f4d-5bbb-4f11-9519-4d3aa15e25cb,"" +f3fd705f-3f03-4f26-a477-f36e65fe7499,false +f4077b1d-84fd-4489-b8b1-bbc9f5b61da2,"" +f475b875-3df0-49fc-b4f9-10b2ac1c40a6,"" +f4bba159-e786-4f15-8100-6bff75c03635,"" +f4e59f5d-12a4-4005-bdae-e157e145c119,"" +f5042323-b136-4c9d-bf57-0b7b70609495,"" +f51f7f2d-968a-4630-8e06-d6beb52b9f6b,"" +f55f863e-ffbf-4eb5-8f76-e2069098adcf,"" +f568f305-55f4-4d1f-849f-6c8f371f5051,"" +f5dec406-3636-4ac4-894f-1035ef3ef570,"" +f5e51d8b-bda1-4093-b887-f2355ea171cd,"" +f5ebecec-331b-4d57-b353-3f50538cae2a,"" +f5ed5cb8-adc0-424c-8371-ffb8e7cc9bc4,"" +f6514087-db2a-40d8-897a-21b5af7d590e,"" +f65d9eb9-e3d4-42fd-8d3b-168a6009f6ed,"" +f66efc52-e910-4d73-a9a7-fddc110c16c0,"" +f67e345d-7f27-48bf-afe4-00d79c3cf300,"" +f67f612c-6534-40d1-8e56-c056e886b98d,"" +f6b9b783-c8af-44c2-8443-44b80e972686,"" +f6bc9618-f245-4402-b69e-74d424736c4b,"" +f703fec9-ca54-4363-9ef0-4c4acdc37e0c,"" +f73ca57b-a00f-4217-9106-aedd26812b3d,"" +f74957d5-eef8-4683-976f-c59ffabdeadc,"" +f7d2872f-bfc1-496e-ae92-a9d446aa72da,"" +f7d6ad2c-1f7e-47ef-adfc-16a5d4d0189a,"" +f8043ec1-8313-45f9-a6dc-4cc1e5ad5f54,"" +f8673366-8964-4c6c-aa9f-02e0920f21dc,"" +f8683b38-42d3-4f32-a543-034c05dc07f6,"" +f8816dca-a41e-4ef9-8a17-b40fc7d707ad,"" +f89b5e47-c8c3-4067-99ea-bd22f8932ee1,"" +f8b6ebd6-8d2a-4592-ad16-06772ad32cc7,"" +f8ddb5b8-70ff-4d5b-adf0-1752811f7be2,"" +f8f99d6a-94dc-4fca-8772-d0c3fe887a7f,"" +f912a4cb-2eeb-41f3-a410-0ddc3eab9cdd,"" +f9185eb8-d2e5-47aa-916b-a5ff24612ddf,"" +f92f93d5-3037-4692-a062-ee84b9961510,"" +f93aa334-4532-4774-b82c-6d040d3c7156,"" +f93e975b-d07d-434d-b227-666e744892c7,"" +f95dafda-7f63-4ddb-acbf-e363dc901b1b,"" +f95f8351-818a-4cb1-b26a-507c4baced47,"" +f9aff2d6-fe39-4d17-90cf-917edf5d2bc8,"" +f9f5480b-27da-44fd-84a6-1ee4d4a55e36,"" +fa0ee43e-abc9-44cb-9248-3acc6c40e693,"" +fa4daa52-528e-45f5-8dd6-fe2a2c9fe8ff,"" +fa522b1a-3244-4203-966f-546dcfb0c62c,"" +fa5e8aa4-84e3-44b7-9dfe-326abdf02162,"" +fa7087f0-0140-4c94-b7c9-185b89c613c8,"" +fa786b6e-dbf4-4c51-a8c6-3006a029e8ba,"" +fa80db64-ef07-4b14-aa7d-e93585fd84e2,"" +faa80ca5-9c2a-40f4-aeec-26d982e663ae,"" +faeaaf02-2ae6-4f5b-b729-61fd56d3946c,false +faf774dd-13ef-4b09-8cc9-3cf33a562482,"" +fb176a2c-4b8f-40d7-bb81-f370c96c3f96,"" +fb1df190-d719-42b7-8e9c-d7830f92882f,"" +fb42fd3a-123d-4b2b-8a2f-d7e37af0a675,"" +fb55aea6-a5e7-4a55-a8df-967f504023f6,"" +fb93624f-3d94-4c5d-9aba-10a3eaea0434,"" +fba16e5e-1b98-484e-8296-43a3995b9f75,"" +fbacdef8-f2e5-4a1c-8a01-b25442a5af89,"" +fc348304-8ef3-4b3d-afcc-a66718315d89,"" +fc6dd798-66ac-45e2-a663-ea69b976c120,"" +fcdd2cbf-917f-4429-a41b-48f8fe2a188b,"" +fd325c37-4113-45e9-9e55-abd6b2ce6dbf,true +fd694334-1bcc-40f0-863a-017311fbaecb,"" +fd75e2b2-c780-477c-a813-046ccec6fe51,"" +fd7a8bc2-9005-4230-a4f5-348f4b1f5b16,"" +fd7ef037-c576-498d-bdef-cec86fdd60b0,"" +fdaeb95c-9d66-4da9-87cf-eabbdc593007,"" +fdb161bd-ad0e-47fa-a5bf-f17ece98f28c,"" +fdb49a29-6648-4dc5-bf56-ef948b00d885,"" +fdbbdafe-ed7e-4bd1-ae67-86430153a738,"" +fdc10bfc-2b5b-4a23-a93a-eaa85803bbc3,true +fdce38d2-ae3a-474f-8024-52279c43b745,"" +fdfcdb50-716b-4452-a4c8-e03d3b8f89a3,"" +fe4c4989-ff06-446e-bf01-5c5d8f69f1eb,"" +fe66bca4-eedf-42a9-8def-d29ef3dd01de,"" +fe719bdd-cc9a-4c93-b2c9-982d051fceb1,"" +fe7906dc-a882-488e-b576-2ef3486bcf79,"" +fe7c2db1-c229-4681-9373-e388dccb9e37,false +fe7cb896-d81d-4b38-885c-4134ea64020e,"" +fe97c34d-b787-4c3a-a972-821eb42a3442,"" +fead13f8-4b89-4f33-950b-ee9254a36c4b,"" +fead2d6e-2979-4de7-8118-698906954d06,"" +ff9df3bf-b8fe-4789-aa34-b205b5143a92,"" +ffab80f3-741c-4c67-af21-4585f1c05d2f,"" +ffb89ee2-c3d9-4fd5-b897-a0e0eb692143,false +fff8bb82-5151-41f9-b150-801ed4957277,"" diff --git a/fhir-server/src/test/resources/responses/ParserTest/lengthObservationSubtraction.csv b/fhir-server/src/test/resources/responses/ParserTest/lengthObservationSubtraction.csv new file mode 100644 index 0000000000..be423195dd --- /dev/null +++ b/fhir-server/src/test/resources/responses/ParserTest/lengthObservationSubtraction.csv @@ -0,0 +1,1502 @@ +0020b035-7314-4867-9453-7921f158d003,"" +002593d4-d271-46a9-a900-1c498c322988,"" +00e9f82f-f16c-422f-81a3-77fa98958da3,true +00f02590-e737-42c4-9c73-206cf66b02b7,"" +011f5b11-f944-46ae-9cde-0d802e5c0073,"" +0143f01c-3692-479a-9a72-592260dbbd64,"" +01a4de83-37d0-4612-82eb-2ff2dbc2e02b,"" +01c177be-05bb-4a44-a199-1df387e68d8e,true +01c17bf0-9240-4149-983e-f0b3ccfb52be,"" +01d57966-1281-42ab-9e05-02d96d146b6e,true +01e27cc9-c9c0-4c33-82f6-9507394f5f2a,"" +0218f780-899c-4c1b-9167-45e33d02acfb,"" +021bf465-c299-4302-99ca-e29a6d25bda5,true +022ebe16-f618-4acb-9d99-88e23d686c34,"" +023a9220-3016-4202-8c7d-360d7d3bece9,true +025aa37b-4ae6-473b-9ae6-c12eece968c5,true +02741df6-79f0-477c-963c-8b3f8cb4374f,true +02b87530-10e2-4009-8734-4196642cef1d,"" +02c07924-f5c7-4909-ab49-dec34c051dfc,"" +02c4fa06-3281-46a0-9bb9-c7b99497c91d,"" +03365fa5-36d2-41b3-b3d9-1fea9f94c73e,true +03555f06-db5f-4b8c-aae3-f6d2c547f499,"" +03610d59-94a2-41de-a039-c671241b075a,true +038ced3d-5233-44c6-9a8c-1f6f9cc4be11,"" +03c7ba3d-8af2-44d1-a3c0-2c56b9fbc7c6,true +03dadf3e-cdc9-4f63-8a4d-89bae77bd529,"" +03e44215-f743-4c4e-8d19-aaf761f54503,"" +0429fff2-2839-45d8-b0bd-1d86aa92f966,"" +042bb1e3-e5aa-471e-9e83-bb4a1b90af22,"" +043108b6-98cc-4feb-8ad0-1394cd10a289,true +04367369-256f-4d47-b1ef-8014109ab46f,"" +04661736-24d8-41f7-9f05-af5682696df0,true +05048b00-24df-4311-806b-2f9a7cc16380,"" +0531e6b8-2ede-4e12-a91b-cfe7e12e552e,"" +054334cd-cfc9-4a1c-acf3-d0824cafd3a5,true +055824d7-b398-40b2-8fed-bc40552fffce,true +05643ef2-65e0-4812-b739-4fadfa3c066e,true +05bed469-760c-439b-9729-0479a6550b76,"" +05c37921-dde8-4b70-869e-82680975ab77,"" +05daccae-2d73-459d-8aea-7ee75966e52b,"" +0624683a-8572-4885-b51d-2197dde395bf,"" +062ab32e-318d-4ff7-81ea-f3be53204988,"" +068d13a5-8b46-4a3b-aca0-ac9ffe70f998,true +071b684c-70a5-4c93-8289-9630d25496d2,"" +072312b8-c984-4cb4-a4f8-97560368576d,"" +07279076-3064-44aa-b07b-346a7edf6abb,"" +072bd136-7e5d-49a2-b878-aaa2c7fde1f2,"" +0735b01a-c65e-4d59-9016-5e3bed1fcdcf,"" +0785f996-ee5e-46f3-8966-107235de4cde,"" +07906572-63db-4046-8dbf-1ae866664f41,"" +07d441b6-4e92-4d6d-af4b-7f38471fa45e,"" +07dfda29-5378-4a66-ac90-fcb7ec6283ca,"" +07f5fcdd-3aa0-4ccd-9122-f9686886dbd4,"" +07f95b0d-656b-4830-ade2-864e58ac5ed6,"" +088cdf48-9645-4dbf-b824-8836d6a83d24,"" +08d37a26-1ec6-4faa-985a-10a9d0ee54a9,"" +092b1b96-4ad3-4716-850e-8056ccd456d8,true +094a486e-7e50-4717-a0c3-07a456a4cd5f,"" +09541c80-54b4-4bb0-8776-37745a9ac36e,"" +09941e9e-ff5e-44e5-82cd-4c3865e39c01,"" +09ab1f16-7bff-44ec-aed5-8ba400930bbc,"" +0a005143-4645-4ce4-89d5-9d49dca18ec6,"" +0a40e26c-d0ac-4653-a54f-17e23ed9a0ce,"" +0a6c1262-dae3-4ec2-b911-0d1caca68302,true +0a7887db-203b-4a3a-b5fb-cabe9a886074,"" +0ab96751-edf1-4941-981c-c6bdcba75380,"" +0ae172de-1755-46d4-8729-d3acc96ce82f,"" +0b6ee068-26bf-4f1b-8423-30f1c591861b,true +0b95920f-7c6d-4b30-89da-51807a6aa557,true +0bbc7111-589b-460e-a742-20f2131c9c64,true +0bd78173-c348-41f1-9edd-884e3561ad47,"" +0c4242e4-1c5e-49d3-bf57-3810f8b88d56,"" +0c93a4a8-3b59-41f8-a7a5-22a9691710ab,true +0c93c94d-b626-40b2-9561-52168c4961ca,true +0cbe226b-6432-41c9-b3dd-0a14c6d54d7e,true +0d1af4fe-50f7-4d8e-823f-192f8a08ec8a,"" +0d7a0166-7fb2-4e1a-b1e5-b03a53fb5602,true +0dbafa74-2f5b-400e-b27e-fddeac8c28ad,"" +0df8e035-a226-425d-9684-a12d0c58b844,"" +0e03654b-d81d-4a62-8f53-b479e8ce3edd,"" +0e11e8ea-dc1b-4e8f-b809-39f0f07c7499,"" +0e8063ca-3601-4741-a2c0-c0381cc6098b,"" +0e92574a-cc09-4564-a2ff-1cdbc89d210c,"" +0e99ca14-e99e-4394-b962-59c66427218d,"" +0e9cc169-ca91-4201-a78f-1b0f724507cb,true +0ed9ee59-d968-443c-b7e4-c3732ec666e3,"" +0edd2d17-3ac8-427c-ae05-40c99b401484,"" +0ee77005-b9a1-4c51-a599-bd233897e431,true +0eea9efa-148d-41d4-b05a-d39484526333,"" +0f13292a-a654-4473-b78e-c8f1b3328ff2,"" +0f67bae5-3bbc-4c7d-84f4-34583758335d,"" +0f68a16f-1c70-4d73-a9b2-fb384585526b,"" +0f7373d2-3052-4c98-9c04-7074250f44cc,true +1016a9db-50e6-4c17-9e93-18a97b67269e,"" +1037da65-9451-48d1-a35d-bfcae76c2c60,"" +10a7d4aa-af9d-4d03-8d1b-bb53ed123f62,"" +10ad7a5d-e26a-4d4b-b063-239af96b0e87,"" +10b85b80-f6fb-4473-a3a6-266f610dcbc6,true +10cd7171-38a4-4276-b911-bcc8092eff7c,true +10fef9b1-6bdf-4eef-b6b5-e12504e8fc7d,true +1104d152-e95e-4a6a-8225-ab200e4530b4,"" +11148ea5-efc3-47ad-8672-799331f8e491,true +114ead73-4920-48fd-847d-f9aa1a99cab3,true +11597b54-9453-4ddc-9171-2be17df7a511,"" +1167e4a5-ce86-48b0-8b96-6d70125e2f9e,"" +11a0c4d2-8908-4c0f-8e51-bf4be1605441,"" +11af3d82-bb56-464a-9203-8714c270f4a5,"" +11cc59ea-52cb-41e1-97e4-7ed651037442,true +12254e32-b86c-45dd-93b0-c8cbee619a14,"" +12257920-12cf-4945-a72f-80551181d7f1,"" +1266203f-94c9-43ac-af02-a0b8db8a93dc,true +12689eb6-84ee-4d28-9c65-3f3e305266f3,"" +127b14bb-027d-4380-932e-ea34c76592d4,true +128cf2ff-4f97-4039-983b-72e2dd3267aa,"" +1333fbed-c09d-4622-b22c-c67dd32e4583,"" +133a1365-e43c-4d92-a6f8-8c3947b13b65,"" +1359fe32-3275-4c1b-ba16-9dc903334044,"" +137d6ce5-93fb-4201-8bf9-0e97e9595b77,true +13bf741f-7ad6-4a14-908f-cbfe18651381,"" +13f4a39d-ec9c-43b4-958e-be28a97972e2,"" +143099ce-8738-4ccf-85fe-63e54943c7f6,"" +146000e6-9926-43da-9322-de3bf31e8142,"" +147add3d-eba6-4cea-bbe9-823b44794b9a,"" +14a9ad6b-b7bf-4cdd-972c-bda91e5066bd,"" +14afc7c1-89c8-4740-a932-a76d579e98c3,true +151df048-c17f-4a51-83a9-3de5f99be125,"" +1520180e-fb4a-4df6-80be-0b3d559c1049,"" +15268027-ae33-4f5e-9c2c-76327ccdeb44,"" +155d0003-f37b-45de-b34c-d611c2a2cf35,true +15821e91-ec03-4e76-a909-d2f2a14c3219,"" +159c1f96-038f-4722-9e36-98f4dfdb6b66,"" +159c3713-0d0f-499f-8ff6-ecddd44b958a,true +15d9442a-2018-4390-beef-55fd90cf6ea3,"" +15e70015-e207-49dd-93a3-7c0ea5cc456f,"" +1631e3a1-0eb3-4d16-a7e5-b0d8a8a9e630,"" +16af45f4-69d1-4190-9bca-b309c17bd865,"" +16be31b9-a434-46e2-a481-459c5584c907,"" +170e5f14-b29a-4aa8-ba71-4bf381a38d1c,"" +17505b4c-c5e8-4acd-9d10-fb001190a8c5,"" +1795e970-0ce6-4d90-b198-32567c690869,true +17d74e33-f6c3-4b19-8708-4110a2f55245,"" +18a57e28-9c23-4e73-9d90-3694f2e373f2,"" +18c6a217-c947-4e97-a764-c43f33a409fb,"" +18e59ddb-b9b9-401d-9239-0d2cb81936c8,"" +18ee3e63-a8a2-4004-a313-3e332af8a173,"" +190f22f4-5fe5-47e5-974a-fbbe63a676c3,"" +191232f1-58d7-4c4a-93a9-10aee15e5cea,"" +1913a538-60f6-4510-9a76-2466896d2a27,"" +193a64c2-63ea-4677-9302-b56e3f0531ac,true +19a30860-10da-4a1b-abdf-0b03d7b8f370,true +19b01508-db72-4c22-a5b4-4e015a3207f9,"" +19c965ca-c1ae-4eec-816f-73903fe43aa8,"" +19d27e58-26a0-48ca-a199-88d48894da5c,"" +1a3ad6e3-cb5e-483b-babc-ba7d34ffacf7,true +1a7b0249-5aa4-4b0b-adb8-2c958e137d54,true +1ac6d3a1-d1a6-4b0c-b405-0aaaaf37c7db,"" +1adf64f4-1fb4-47f9-a8a3-0ebeb3e7f414,"" +1af4a596-d0c3-4f7c-a217-b83a0755c3b7,true +1b091e60-4c4b-4fb4-b9b8-ee53bccc9b52,"" +1b251a42-a224-4a0f-9d36-44ecc8902d08,true +1b29b772-b873-447b-8aa0-5dd5e9ee1b80,"" +1b614d48-0af0-4d09-a6af-4f3af065da14,"" +1b785bb6-a40c-48e6-a464-f8022ea3cdcb,"" +1bb3d0c2-c6de-42ec-bd60-edc8e3ccd092,"" +1bdd0326-987d-445b-9514-2ea30d948093,true +1c01b494-d0c1-4a99-b110-9de392bbcf69,true +1c120e92-0385-4120-ac83-1b42191597b8,"" +1c32d0e8-7312-4821-aede-6745a83ea45b,"" +1c51f4a8-14a6-48ad-9821-c6408dd0cd33,"" +1c52440e-0063-4170-9cff-a3caaf7c63fb,true +1c6dd7c8-4942-498d-a369-65fac6a837d6,"" +1c79c271-a128-41be-9537-1d744f4971a8,"" +1ce6a20a-2413-470f-86ca-2dacd8811e72,"" +1d9b87ab-8b41-4184-9519-fa9822f48aa1,"" +1da7f725-2fee-4f33-9a89-96253d2449fe,"" +1dcdb77f-b0e5-4b2f-ad4e-d446a6ffa079,"" +1ddc3c30-fccc-4e5d-a9b2-e09ac4f64dc0,"" +1e2bcc56-3121-4b1f-b9c7-7e5503b867db,"" +1e5b7df3-5e81-41c5-b096-d9b5409268ae,"" +1e75c4d7-b570-4339-8c0a-06bdfc9bb485,"" +1e84c68a-4e0e-4980-adea-e46ae2506896,"" +1ea31cfd-f340-4c68-a547-b76365abd1bd,"" +1f170771-0d08-45db-a38d-da3c539b46b0,"" +1f182acd-6bb8-4031-aa86-2f3dd83b4cb7,"" +1f3e4d9e-1fec-4a71-98fd-4912ab64d3d2,"" +1f6b8ac1-b12c-4eb1-a158-25b15965294c,"" +1f8ad9f7-f796-4900-b10b-365fe442f2e1,"" +1fb81c48-c8d0-44e1-9b9b-df53ad7d9456,"" +1fcab6a5-85c8-41b7-a820-fe6e2d84eaba,"" +2031d9a4-3e03-47a2-ab74-6fe7f2fa4ba1,"" +20d47a7e-f7f1-475b-a9b5-6192f2fce0ca,"" +20ee5488-a11f-418a-86a9-cb981c2fdae5,true +2123f57e-0815-49e1-aa34-994270134f3a,"" +2160f03b-4276-436a-8278-300bedd07f7b,"" +21936507-6a38-4d80-807d-0d7cb5ea0311,"" +21d2fab0-5092-411b-b752-4859134a7aab,true +223cae66-3049-48bf-be7b-cf027c415743,"" +22440788-7e64-452d-9025-9a25e4d2be60,"" +2245208e-d17e-4bb7-9bd7-ac75ac0ba134,"" +22462877-9663-4c06-bb5e-040d76bb144f,"" +2253a94d-e511-42bf-a17c-599ae2d5cf0f,"" +226d433b-9abf-4e98-bf0e-47cb3a37b41c,"" +227d84f4-ec92-464a-b3de-f596866ce825,true +228b1b4e-f5e7-4e33-91fc-b7cbe6979102,"" +22b95566-7a4c-47b1-92af-7e0ecbfee6fa,"" +230b746a-26de-434a-9774-54db1ad98a7c,"" +2324dacf-f221-4edf-bdf6-924449cc916c,true +2381d397-0068-4d6a-88e1-a0257d81a323,true +23831569-6aea-4071-820e-6eb5440acc1f,"" +23b4fe3f-62c7-4439-9364-247ceb9251c1,"" +23f91a73-1b46-414b-becb-918e84177886,"" +2439d9a3-6c58-4ced-a82e-27908ed3df94,"" +2450caca-d74c-4610-ac24-1fae13801eb7,"" +24d8f04b-f035-4a9b-b03f-75be9e244ceb,true +25085ba1-43d7-4a60-82ab-e15c477313b0,"" +251e7497-4a55-42fc-8e6a-32febded738f,true +2534b076-583b-4872-84e3-bc96bdee5ef0,true +2583c0bf-6a7e-4100-a5c1-d249de6ec56d,"" +25da1be8-51c6-41fd-b48d-5227e804ebfa,"" +25e1a428-ab0b-40f5-ac25-1e9899458ec7,"" +2606b58b-a924-4128-b3a4-5e4b91deb692,true +261583fb-e2d0-44c0-a677-00bd89a3450b,"" +26344e09-20c8-4405-b674-49638169a7a0,true +266c347b-fa2d-4cc1-a2fb-fe1ba20fbc2e,"" +266cf373-c41a-4cc3-8600-c165a4349a6a,"" +26b4001f-2917-4bf5-bcbf-1ce9dc258171,true +26fb6882-7f3e-44da-9100-58057c9aeec8,true +277e09d4-cb89-4748-b9da-39bee94df8b3,"" +27a75a54-d318-4026-bd63-c80f73899376,"" +2803a9d2-2555-4bc6-9718-7a9dcabd6ce4,"" +2803acc2-63bf-49a3-b4fb-0dd0742fb816,"" +281d5649-179d-4c8c-9a0a-d1159a5df8f1,true +28503262-5aab-44eb-bf51-6fb7534c25ab,"" +2866a0de-36ab-4ec0-a1e1-cce5c697ef85,"" +286decfc-83d1-42e8-9a2f-880f145c71b3,true +2875fd27-8c5b-46ec-91f0-ef3a7a7727b3,"" +28aa1696-dde7-40ff-bb7a-6c5b614405dd,"" +28e8966e-ba9b-4499-bc9c-7f51222e15aa,"" +290440da-118e-4e8b-8d0e-d50043c24eac,true +292aa324-379d-4b82-9750-4c8e23587f92,"" +29506f88-302c-4264-81b7-cf762de48615,"" +29546a71-e5a0-47ae-96da-421275c2cce1,"" +29676c08-88c7-4b0c-82c9-5f6d7dd51f68,"" +2974e695-f2e6-477f-91e4-da8eb654bf24,"" +298120fe-5dbb-4d99-902a-3a6783fc5b6b,"" +298e5099-df2f-4381-8259-b10d0b8c0570,true +299c851f-3566-405f-a217-84c0703d859c,"" +29b17fc8-8e80-4d7d-93dc-bdba1f2cfb9d,"" +29bfab6a-d760-449c-9198-38e8c63574f2,"" +29d4d79f-8a85-490c-b52d-aaf3bcd9a100,"" +29e54cc5-b484-4818-9c3e-08074812dc7f,"" +2a0d7eba-2dbf-4566-af0a-c16161a8b189,"" +2a133e8f-4dd9-49fd-9e3f-5cf122294091,true +2a67b2c1-18cc-45a0-ad53-825c73a3aa15,"" +2a71ca62-7f39-4c9b-b3de-6dfcf299298a,"" +2a7f0959-9d50-4ccd-88e1-6635f2502905,"" +2af24d01-6215-4c7b-88b4-6cee45a156f3,true +2b265cf1-0763-4922-a403-e6f644ed95ba,"" +2b41d0b5-97d4-4a80-bf65-b62ac0cb530a,"" +2b4fd497-9f28-4c87-9b13-64f0d00c0cc3,true +2b54e31d-4af9-4071-ad49-60cae644ba39,true +2b60fba0-0143-4f31-8e4c-27236c7f41d8,"" +2b927027-35f1-488b-bb5b-127a8985cc5e,"" +2bc92150-c490-44da-a925-ebddec5cd953,"" +2be63080-a881-43df-95b5-e371df93c6bb,"" +2c018134-14c6-425d-8ab4-bc3974402b05,true +2c3b614e-7860-47ad-9320-11c5f45d27b0,true +2d358911-c5eb-480a-a9e6-a6fab52ad7c2,"" +2d45c298-d386-43ab-b3e0-ba07dc527a68,"" +2d6cb13b-fdfe-4219-bc13-7de385998bcc,"" +2dbd4567-e6aa-4e1a-996b-af8384f66b37,true +2df38530-e49e-4ff9-93a3-816de29d9bfb,"" +2df89473-f746-4086-a2f3-8ee2d4f63271,"" +2e0bc41c-fdfa-42ab-abdb-28f13cf2ca20,"" +2e13cb39-148f-4299-b74a-0a8e10092e9b,"" +2e45b9b5-8d45-4994-aaba-1fab72c77c5d,true +2e6b11f5-cede-4152-bfe9-523b030a2bdf,"" +2e8c312f-53b4-4cd3-b6da-653c34945d76,true +2ea2af0e-343f-47af-b0fe-6dea108836be,"" +2eb09ab4-c554-4536-a3ce-2979cfb988c6,"" +2edee289-e99a-4a53-a067-f83d29db4c2a,"" +2ee72185-ca8f-40e3-b82d-30408dc8c6f2,"" +2ef91918-bdb6-4a6e-9c39-41d8c513b552,"" +2f1bbdc4-beaa-4d49-8791-6548094c7291,"" +2f24078d-9646-40fb-908d-2628d555dcb1,"" +2f260daf-8fb3-4fb9-a435-670ec8f0180c,true +2f30832d-e6b8-4946-8cf4-0d8da5c359c0,true +2f33b981-f22f-4983-b347-f81d7d72c50a,"" +2f3f7f7a-ba31-4c1e-8a23-c7d1eb1f255d,true +2f5d7d1b-847e-430c-988a-40028f9f595e,"" +2f8b35f6-2b55-4ff0-8d79-5de7805d6da1,"" +2fc9f8c2-4a1e-4e8d-8d91-a6c3b3937e8a,"" +2fcfe30d-dc47-4eaf-9df0-7943a2c37fc5,"" +2feac451-2301-4ed5-8bca-baef62790656,"" +2febeae3-eb61-4743-8ff9-42547a77a40e,"" +3006707b-dcca-41ce-b138-5d62e6b56984,true +30371578-4ad0-498b-a491-4e194c7466fd,"" +305d5449-57c6-4362-83cf-55b4dae133de,"" +30ba9f80-e595-460a-abf2-b8f46a62e606,"" +31504825-77aa-4a0f-a634-ca806bd886d3,"" +3169cf91-33f7-4b7e-b49f-d4b884760685,"" +319dfae4-0305-4520-8ad1-9679383cb74f,"" +31acc736-076e-426d-8a32-426d91bf6511,"" +31e26c46-af6e-43a2-8e27-a8342f53e817,"" +31fd2352-7eb4-4ce8-9dfb-b3d3a1410c82,"" +322637fc-2d75-4a8f-89a6-a4c963869112,"" +32596eae-6236-4b3a-99fd-e50856971f59,true +3286c996-861f-4fe3-90a8-86ec826cdf9a,"" +32bed860-5df5-4bbb-8bd1-c95c016561ee,true +32d92e2f-d02b-4006-bf16-d1c535948e80,"" +32f3d9fa-6c64-49e8-a6dc-fb51679753e5,true +330fde18-0a86-4e67-850d-fe1c8b376dab,"" +3322da98-67e0-445f-ba1f-225eb7d297a3,"" +33333f69-f8a6-4def-a5f2-bab5a26bf054,true +33826788-b600-476b-9843-17fbee2cd849,true +33a0b9dd-c88a-46cd-ba8f-af3d4d6cfc27,"" +33ac0c39-1552-408b-97ea-a90c9187d61e,"" +33b22ef7-01a8-4e8f-8b5d-9aef37e46896,"" +33be0567-5c42-451b-bd71-c09f7de30524,true +340dbb93-0888-4f47-b18d-0b86d3e40248,"" +341634fb-2646-4c69-b57d-b5f00ff4c83d,true +3420a3d5-d5c7-402b-a4c5-02e7198c5b7e,"" +342699a7-cb58-4a9f-bb79-306483dfa652,"" +34335eed-f6c0-4e05-ba6b-1ecaa1fc121c,true +346734fc-4798-48e3-8880-a603d52e9ca9,"" +346a282a-439f-48ac-875a-cc34643d70cc,"" +34a83c04-2ea0-4638-ab6a-0a4bb9a3ad4a,"" +34e44ce8-26fe-48c3-8fe8-5cd8f260aee0,true +34ea288c-f987-476a-a8ed-0ab2c1b92833,"" +3590f230-1be0-4c7b-afc6-5bffec9933ad,true +35cf6113-d23a-476c-b18d-f86fbfb3ea2d,"" +36160c58-889f-4543-bf04-dd29cac9ce19,"" +361688f0-e909-4c9a-b5d8-10727c9a18fd,true +365ca17e-d5b1-41d2-982e-3ca7afdc0a0d,"" +3669a209-82a0-4f9e-8026-43cebad7f3ab,"" +366fa6b3-9595-4624-ae30-20257ef4885a,"" +36957f27-97d1-483a-a8ea-bd5b1484ad12,"" +36c9ce76-e047-487a-837c-faffdb2676de,"" +36cc6703-7757-4c6b-91a0-a43055c19bb6,"" +3732940c-2fa8-4301-942a-e58fd8d73421,"" +373609ea-276f-4b96-9c94-d96ad532246b,"" +37770a6d-bb26-4499-a6e6-2eb399a8ad07,true +3793c189-6e61-4f1f-bb19-a01a306267d7,"" +379779f8-dbce-4dfd-b18f-ce0485b0d6aa,"" +37e1570f-2c29-418a-acee-6688b6ab4279,"" +37ea3114-1b65-4c47-9e65-4cbcf339f8c5,"" +37fa89b6-2f6e-4985-b733-1ee4b2fd59e2,true +381dcabc-52cf-42e9-9624-d4e1270518a9,true +383aa480-8db2-49ed-9542-c738af90f344,"" +38898dca-756f-4267-aa1d-1fe52a6e4749,true +389079a9-b902-4212-a8c1-7187e818e016,"" +389a8f10-ad75-4d27-9d11-2c4ba0dc55a6,"" +38c329c2-4078-450f-ae85-e411b80f30ce,"" +38c7c98e-0372-4892-aea0-ba21ed298958,"" +38d59ef7-b207-4d55-b74a-a1da3d0c10df,"" +39d3bc28-0ce7-4d1d-9adc-bb9933568809,"" +39d7db36-7baf-43d7-8a0d-970ae00456d0,true +3a1941c5-c6bd-45b7-b306-d2a1a51c5eab,"" +3a8a0b91-a492-42de-9b64-fc552476d8ff,"" +3aacaf9d-af9b-4220-a836-1d0c3cfd5245,true +3ad5553b-58b8-46c9-8023-e1acb85be08c,true +3b4bf6ba-0f27-4228-b6e1-c16dbf82e5cb,true +3b7c654f-9a67-4402-a571-a5b0a61559ab,"" +3bae6ece-f05c-4e3d-81a7-64f10f907bb2,"" +3bb8d5a9-87a6-4155-8f3a-7a0c841672c1,true +3bbe3af0-0f3c-41ee-9c41-70d89b411852,true +3be31b98-5218-44c6-aa92-1e054793d9df,"" +3c496888-2ead-4d5f-afa4-8ab39b57ca03,true +3c504a58-92fd-4b2f-a308-21a9588b1850,"" +3c8d926d-3156-464b-b385-192257411798,true +3d2c40b9-2ef8-46d7-8215-bb898170902f,"" +3d87abf4-a569-49b5-962b-32c11816a53f,"" +3dac5f75-f71c-4092-b87a-7b8434af633f,true +3db4a850-ef45-4fa2-8eb1-b1cba4477d8d,"" +3dc0190f-39b2-4a1f-87d9-1ef41a73fa75,"" +3e4206fe-8856-46be-98af-d6fecd52db92,true +3e58093d-c387-4a07-85c2-41a519d0c398,"" +3ebd1cdb-5546-4dea-ba79-a88aef933640,true +3edb8e33-d674-4c25-aa75-7303da0229b9,"" +3f5c46c8-4a8a-4575-b169-6bfd5d752d98,"" +3f771434-cfed-4f34-9671-0ef302b5f9e7,"" +40100d97-ad9a-459b-b044-66568d36c0bd,"" +408159a9-8c38-4cb3-9488-d83331f1762d,"" +40a1dd3f-6ffd-4463-bf71-42057ee61689,"" +40a75d7a-909f-4657-9ac1-5b56df539129,"" +40eec0cb-8f50-4f61-92a4-7682c48511f9,"" +40f3ae1e-4855-4d78-9fe9-c8348058088e,"" +4115b0b4-f738-405b-9351-ae11ba4bd07a,"" +411cbadd-c2d1-4fb3-8ddb-d8bcea3aa176,"" +41496990-adc5-44d1-96b8-15010bdecc89,true +41a3cf00-0965-4c17-bfb5-247a7da43699,true +41a86c21-2ea1-436a-86a3-9173c7d95d9c,"" +41de6042-e95f-4bca-ba69-f55293248f7c,"" +41ecc0b6-ae98-40e0-a836-9d26070e248c,"" +42187018-d27b-4831-913c-575d07e33c54,"" +421e31e1-5ffb-4c6e-957c-728b6218d6da,"" +42350e13-ab61-49ef-aea1-802f6b7ea955,"" +423800b8-5a89-4eec-a12f-451c533fac50,"" +42895609-81ce-4cef-81db-069efe9a207d,"" +429c5342-c5ae-4c55-98aa-e4f7bf0b4670,"" +42ac25e5-8828-49bf-bb5c-a6001966c6ff,"" +42c5e47c-ede1-48eb-bc82-2ed835d67495,true +42fe77c3-239a-4afe-ad76-8c221b543e32,"" +43179e01-e94b-4f83-bb60-60f181388048,true +432bf1ce-0e8b-4621-b998-819fee53f80a,"" +43522eea-96c7-41f6-ad41-1c190cece6aa,"" +4358ee55-cc06-46a0-8b44-6b89d09c380f,"" +4380d762-baa4-4c30-905c-59b33dbd793f,true +439dfa4f-917f-40c5-9313-0d5dcf7ecf2f,"" +43bdfaaa-7474-4503-ad93-730d777e6db8,"" +4416e165-8ac3-43e0-a9e4-6c3e789ffdd2,"" +44233ad5-4eb9-4709-9c6c-e7797d9c9f1d,true +44237e1a-31ca-4635-9ff3-e3c71f587972,"" +4442a5e3-5793-43ae-92ab-f2d87a70cc0b,"" +446f7fac-2202-4149-9860-fe48335349b3,"" +44713d16-f673-456a-881b-b0526ee36651,"" +44b741ee-bdb2-4732-b484-e435854de348,"" +44dbff22-7cac-4f70-886f-b8ac2dea7130,"" +44f714c0-88de-43a6-b69a-4d62d8fee57e,"" +4522ef75-31ae-43e5-8e5a-5caf5c83fb35,true +453cd2e7-723b-4e1d-b414-f46f9152edcf,"" +45467cbe-cc21-4822-94f5-82e1203056ad,"" +4546f579-74ab-445c-8619-431f60a6efdd,"" +455f8ebf-b074-4035-915c-91cd15380d72,"" +459f6da9-0eb8-4b26-85b9-a8f63c587fab,"" +45a306de-3731-40c2-8bd5-2c0fee3b9f99,true +45d45783-5a68-4c06-9b2f-88b7ea1f8347,"" +461bea3d-934e-46fa-a112-9a761140372a,"" +4672ebd9-08d2-43fc-ba92-ce13b587af3b,"" +4675fa7c-6ac8-4bef-8756-88f757370a10,true +4680ae70-6d17-40fe-b55a-c3152ce8b246,"" +4687b275-d990-41cd-a146-2715079a8ecd,"" +47014b4d-07f1-4bef-9792-82c027525c0f,true +473bf60d-dab0-4531-9903-95dc6680a660,true +475e95a3-6d57-40f3-a0af-9daf1b35618b,"" +478fbabf-520e-48a5-b3a1-a3e535d64345,true +47971ac1-1e72-4788-ba6f-bea608e59076,"" +47f066d8-abf5-4064-84fd-dfb05649e0fc,"" +4808c4d5-7733-4601-8401-632bf5924c06,"" +484a19b7-9816-4a66-8f0b-51cb5f146818,"" +48693756-94c2-434e-ad88-e573e5278a6e,"" +48fae21d-0ac1-4e4a-93b7-ac4ba7c2a606,"" +49088daf-d19c-4bab-9084-c67f0fba2c90,"" +491118c7-998f-4d45-8b58-da724ac011e1,"" +4925b797-e285-4d02-9aed-dfac19b0875b,true +492f6c9e-3e1c-4043-aa08-03c610da33a7,true +49466fee-df56-4b9f-898f-96b65318d833,true +495bdeba-9ab9-4756-b4e0-a4aa8b039a02,"" +496f0696-cee8-425a-81d8-1df8fd17e4bd,"" +49cce532-3ba4-4db6-b518-ea934588bfae,"" +49ee8b11-a7c9-455e-9a9b-835dd617e861,"" +49f41136-fc63-48a8-8ee2-b7536d3bf0e7,"" +4a6eb9f9-49a5-4d36-85dd-78512fbe593a,"" +4acf651e-af55-447d-bf0d-9adaef4cf6bf,true +4ae0f855-534f-41dc-a4b0-879c771e3379,"" +4aeca194-6d0d-48ad-8fd4-6aea3be783fd,true +4b322f4a-fa06-4509-9783-dbbf12960b77,"" +4b68a6bb-4fca-45ae-bfb4-b814c67bdac7,true +4b86609f-db97-4a0b-9860-3ce519072521,"" +4bbf3839-bd13-406d-9f60-d9eb9daa4dcd,"" +4bd9e2b4-e195-4a83-ba1c-478e66a7bb5f,true +4be334e3-94a8-4223-846e-39b5877e9ff7,true +4be59cbe-d89e-4abc-aca4-410a7e8cf580,"" +4be72d80-9418-44de-ab47-e8f2f2b9f2e4,"" +4c9a28de-ab9a-4e69-9ca6-375512c2f149,"" +4ca8a902-7ac4-4634-b1df-456175c39d14,"" +4cef34bd-c677-4647-b940-840a6868cb9c,"" +4d0e9887-c81c-4ea0-9026-41ceb9ec9a51,true +4d45564e-e14c-4289-a637-06193bfcef2e,"" +4d79c0f1-72b2-4e94-addb-9adce3f49c2f,"" +4dad93cd-b188-4750-bdb0-4a5501568d81,"" +4db059c5-c4d2-440a-84ac-360312e3c590,true +4dba5ae8-2d30-479e-b831-80d39c396280,true +4de45bfc-2a41-4e0d-a0e7-c6caf6ca0f24,true +4df7ae55-1947-4d89-b51a-496b34c4250b,true +4dfadd90-3f14-4ee9-abbd-a348a5d6a7d9,"" +4e0d77a5-782a-4b03-8867-f51a9704368f,"" +4e74bab4-e328-447e-84d9-a29bb7fa1548,"" +4e8a0b34-71b8-4da8-80f9-f015782b182c,"" +4e9a316e-406b-496b-acf5-6eec80f25ee7,true +4eab3a46-0ea6-431a-8c65-5b5bdee521cc,"" +4ec34b7a-8389-4d01-bca5-06e678089d41,"" +4f147e12-0e70-4ddb-b4e9-4ea25361f290,true +4f18952b-be4a-4d77-ad4a-05276a6bce1d,"" +4f3f5836-8683-49cb-b5e8-a9881796a202,true +4f62ec59-e478-40ef-8617-e6ed599866f1,true +4fe2d379-ba65-4ee2-a584-f0bc63a8523e,"" +5005cfbc-b57d-442d-976b-34164aeb1977,true +504859eb-2ed0-4184-99f1-79f436fcd692,"" +5085d62c-dc5e-4f25-8f0c-700e57bb71fb,"" +508de40d-3c1a-4bfc-8713-11dbae730004,true +509d7086-3120-4f61-bc92-4ab924f30ffa,true +50a9341a-67f3-4d18-9118-373db23eea3c,"" +50b76e4f-6575-47f6-9e15-a96b58c492f3,true +50dbd55a-e4db-406d-943e-7624d96c554b,"" +50fbe67f-8d29-41a7-8cc6-3df916cd922f,true +5105a245-dc96-483d-9a0e-52b39e664d27,"" +5106bb8d-43a4-4783-97c9-42d707990a2c,"" +51164c4a-fa5e-4246-80e4-a01e1d7707d6,"" +512a1f5b-9f83-4420-a4e4-978e33432dba,"" +5253d689-c7bd-441c-ab16-3721f1e3b5cb,"" +527721f5-443d-4367-84e8-0f15982e7587,true +529479a1-36f6-4133-bb4e-2f3cf677626d,"" +52c03be3-5715-4edd-9809-ebff7e2ba57c,true +52d51fd3-d0c8-4046-9ec3-1a3f523d0b75,"" +53010db2-bba4-4751-9f12-f51429c9c558,"" +53339064-e7f3-47b0-a5c6-ce77d50b7489,"" +537bd7f9-9f4c-4bf1-bc21-9d09dd655a13,"" +53e5edab-cd6e-42cd-b6e3-a36d57be3685,"" +5441b3d3-b8e8-4e36-84c5-623e9b199daf,"" +54487624-db9d-43cd-b4a6-0b4d3934f7bb,"" +54627df6-151a-4f3c-9fea-374217afba2b,true +5496c32e-97eb-4f6f-a7ee-46bd2123f966,"" +55054683-a9bc-4c84-b1b9-6a1540e1168f,"" +55449cc5-a88a-4181-9550-5d2bb23a293e,"" +5565df4e-b483-407b-8816-ca9e8ddefc27,"" +5578c18e-84ae-4f7a-8cb6-ce285e1b1ff4,"" +55936779-3082-43b8-a1e8-a8329bf19a8c,true +55954c84-4a6f-4667-b070-5fa9185fe3d2,"" +55dc6b95-e01c-4812-a812-2cbf20de74cf,"" +562f66c7-19ed-4d05-a14d-6aaa37e6eb16,"" +56617f73-b5fd-4e8b-8bd5-467af440f0a9,"" +569f7616-50c5-47c5-94c8-fa3b3097bc97,"" +5703a2ef-ccc3-4ca0-b100-a1c567f1dfc4,true +572e67ff-4f0c-49c4-b55a-36a958d3e02f,"" +5742e203-dd0b-43c6-9dfa-304240238737,"" +574873f1-84ed-4171-a51b-6a2c609e9afa,true +5760bdfc-cbd9-4763-841a-bb31a972f551,true +5781b9ed-eeb3-45d3-a364-43cf8ea348f6,"" +579a0bf9-87da-4887-9700-a5098cd7d720,true +579eb155-01ea-4066-9dae-9ddce5ea2041,true +57d84d96-a1fd-44ec-8460-588b477502a5,true +57fa04a3-a8e7-4699-9115-95957be21dea,"" +57fec813-6327-4290-a2e2-ca74a04cccf8,"" +588b882b-0bff-427d-8b34-294f2fe55189,"" +58aa2384-e80d-4083-a173-ba534f152680,true +591075a3-92bb-42b7-a6b7-d761add1ad2f,"" +598288b2-fa85-4bf8-9e01-2d0e86711aa7,"" +59857d17-d8e0-4932-b92c-97bd36a31d3d,"" +59a25b17-fe55-4592-abfc-0c22e237bbd9,true +59b131b5-2db4-4877-bcc1-2206865df718,"" +59e29c4a-102b-46a3-a950-3babee7cfccc,true +5a0eb3ab-86ce-467f-b389-94f026fe0f7f,"" +5a4bc06f-8ed6-4cbb-93f7-5c5faee7e855,"" +5a9300fb-d831-4b67-88b2-843d2eca4441,"" +5b0954c2-a2cd-4013-b866-a6e0474c12c6,"" +5b2730a8-6a24-4bf7-aacd-f56fd380c696,"" +5b44153a-1ea5-45a1-9d58-bbc0a474ce1d,"" +5b5f6d2c-1899-474a-afae-a98762630b06,"" +5b72c7eb-4584-45c0-9039-5fc762b1e50d,true +5ba15ba9-7112-45ab-b7e5-353d52af5fe3,"" +5bb09da7-8ce1-4642-a113-fdd1fbc73897,"" +5c085687-51d6-4cbe-9b71-0a58718c1d24,"" +5c17c3d7-a7ba-4756-9991-97bc0b3a46ad,"" +5c48ba78-4e71-441d-b03e-ef305d9e2bde,"" +5cce02c2-3537-4d34-b085-7cf145590292,true +5cd558f0-20d1-40c7-8197-5a41ef97e634,"" +5cec04b3-e52d-4a6c-af98-6ee5d104b20a,true +5cf73976-33ee-44ac-aade-5c64e56d7cd9,"" +5d54c744-365a-4db7-9675-79d64bdf55a6,"" +5d5dad82-9b58-4302-a494-02f44c3e94bd,"" +5d790c80-5b87-4802-9b89-02f949846f39,true +5d883f31-f417-4d8b-bdbe-2cf73d1aa4b5,true +5d9e8c9f-8c95-4ca2-9de2-2cf875868ff9,"" +5ecf975d-fa2b-4c6c-a5e6-fed730c9e035,"" +5ef7c113-d5bc-486c-9be9-aa39aea779d0,"" +5f6ad8e2-eed9-4b2d-8697-4e2e742ee1d4,"" +5f92feba-5842-4894-907b-9ceaf36d0f38,"" +5fc1d33e-168e-435c-93ae-c619999b6f9b,"" +5ffb50f0-0963-43d0-b032-3e6b2621e1d7,"" +602f4e55-f69c-4103-bb6e-7d23fd1b06ac,true +6042dc41-8cdc-4825-9ab2-bb22af5c5fa6,"" +60635e6e-3d74-4f56-acb3-be8edc522837,"" +60959eb0-ed9b-4043-b8a1-0b0f27789642,true +60996e5d-082f-4d1e-8cc5-6cc626974925,"" +609a5704-81f0-4b67-881c-d00e87b74c0a,"" +6198d258-17e2-4956-8064-1448f4744303,"" +61e75b9d-46a2-4d74-a0f0-37dc66a09450,"" +6220b92e-946e-449a-a2bd-3241e6a453a9,"" +62346d78-6be2-4cfb-850e-6ca1fc3f5e35,"" +62348772-d9cb-476a-a016-32f16e44cb33,"" +62ad1938-6235-48d8-aafb-2f773a40c6e1,true +62ccafe7-fbcb-4cbf-8584-224cd58ef421,"" +62e4244f-3f34-48f4-b865-c8b1c3ad97f5,true +62f342e2-5499-47c8-959c-4d786aa5fd67,true +62f6ce69-77ca-436c-9d40-3eb541853798,"" +6320229b-25c2-4355-a288-17efb054df6f,"" +633dac04-7a54-476c-8482-9631c351ac26,"" +639dab1d-3282-4de9-84f7-727d0462f11f,"" +63b2b9b1-aaf2-4539-97f6-aa6815e75f21,"" +63d6c1e2-ce14-4e89-9bcc-f3e3e0b6fe72,"" +63e5b7be-525c-4a0b-852f-4cb090178d30,"" +63e709bb-a56a-452b-a48c-5125a367572a,"" +641068ee-0805-4403-a159-4fdb185cfdad,"" +64115066-e659-4cd0-9a56-fcd43a6df27d,true +64148c8b-89e4-4394-b044-27088ab3adc6,true +6433bbab-cad9-4e98-b488-c06e37acf268,true +645572a4-5806-4854-b89c-939463a904f7,"" +64a2df8b-688c-4368-b672-0406ac7032ad,"" +64c6ac23-d619-44aa-88fc-969376bebfcb,true +657aed74-c373-4c45-9de7-b75cdf62577f,"" +65ad0ff6-ba27-4eea-a400-3d96240a5702,"" +65b9a660-2f5f-4d9b-9f15-5e572d65ee9a,"" +65e87fc6-9232-4ba9-baae-61d7af6e54f4,true +66037242-eaa2-43af-98ed-190c3079833e,"" +667d62a5-160b-4657-be40-beeb787d51d7,"" +6683a92d-2d09-4875-9403-b977bc2eb37f,"" +66be2f9e-fffe-454e-86ae-75dc713ee934,"" +678223e6-745c-4d58-888c-b910dbb9039f,"" +67cf1dde-11a3-4aff-a7f2-a8b8288aac8e,"" +67ed7f4f-4873-409b-a04a-b928cb461719,"" +68059a10-b5eb-41c5-bb44-c56ecdb6baf1,"" +68249708-6a5c-474d-b1f1-214514fe5dbb,"" +682b9750-e94b-4522-b277-0d572b67e94d,true +68935870-c60d-44c5-b57a-000c0a99e9d2,"" +68a1d32e-915c-417d-98c9-3154ffbc9249,true +68a84b5d-edb4-41ee-82aa-8612ab7b2b38,"" +68dc301a-6b81-449d-bcf0-7b2f3d3335db,true +692cc2c1-44b0-4c47-86b1-2d3c4a5848bb,"" +6938bd7d-06d6-4a9d-8234-9123aa238788,true +697d10ec-d72e-49b1-b2f9-ac8a3be5c856,"" +698df1c2-7cc5-44cc-ab61-5420d92c598a,"" +699d6871-1043-4581-8dfd-fd1b6e47d518,true +699f0f86-fc10-4f15-9a78-19515e4e4958,"" +69ae7f71-a967-4c7e-a046-cef77b622f70,"" +69c3f870-e1a5-4785-8dc4-067a7590b949,"" +69e71f61-bde7-494c-b65e-346f5972d21a,"" +69fe60c1-d372-41ec-8671-94090b970a7f,"" +6a4adab1-6b87-4e61-a400-dfa4aa4af613,"" +6a50955b-b259-464b-b3ab-9fa173caeaa5,"" +6a8a69b4-f6d9-457e-8466-fdf87ac0585c,true +6a967445-47ae-46aa-8754-2e48915efc2e,true +6aba4aa4-9fe6-4759-9f76-705127be70c0,true +6b8c1da8-2bca-4e16-a04c-a99a04c76d85,"" +6b9af3c5-cc2a-40af-9264-1c68ea98d031,"" +6c18b368-8579-42e7-b0da-3500ed15ab82,"" +6c3be815-1494-4c82-b655-a3e7c92ee945,"" +6c7689e6-db2a-4544-bf19-0b70c6d74279,"" +6ca383d2-551e-4c89-b07f-c0faf9b36dcf,"" +6cac250a-d650-4c9d-a896-b38dd7e72955,"" +6cc22c4d-6014-44f6-a1e9-0b8eaf3f837a,"" +6d2776a9-6add-4222-bb43-64bd4dda65da,"" +6d34e7f6-d885-49f6-b072-6d06f6677a2d,"" +6d564224-4c2f-4bbc-af57-9895ad3b57d6,true +6d5ff978-ef70-4eba-a1db-536985901dce,"" +6d759795-d565-43ce-90d5-91b167b18c10,true +6d813c64-a15b-4e50-af82-c2f18f82a0cb,"" +6d94712f-7565-424b-ad4a-e1789fe2a639,"" +6d955124-bd23-4958-bad6-b36cdad50a5a,true +6d986c2e-b12b-4a6f-ac80-d3bcdaede076,"" +6e02f522-f081-402b-88f2-38e6622bd006,true +6e362fd8-b0b4-4cff-85c3-6586920627ad,"" +6e750faa-cf8a-4f5e-a02d-1471741cfdab,"" +6ea2fcf1-31dd-46e4-be06-592626e212f5,"" +6ea7ff7c-35f3-4350-9f9f-104c5182cd0b,true +6ead6acc-52c8-4df1-b00e-b46e2e2f0a04,"" +6ec2fab5-4d76-4c80-ab2d-577b041c1aee,"" +6f550b68-a7cb-4314-ba74-d7d2a6d56d0f,"" +6f63c413-6f3c-48db-990b-fcc749cc6355,"" +6fb0d554-b14a-4bbb-aa5f-a4d5c082c2dd,"" +6fd78455-d026-412e-ab31-d9e1a02923dd,"" +6fdefa93-f23b-4eab-82d0-1e9ce7c6c17c,"" +70777428-a2a0-4dd6-b048-1ef2a27d9ec6,"" +7084e394-9ee8-4b0e-a3f5-e8d091ab4fae,"" +70a25de3-45dd-4848-a394-e87d4f6b6930,true +70af4c33-277a-4a9b-8022-60d6bb0ac6aa,"" +7102c0da-2afa-4da2-a79b-a82742e4e3da,"" +713231d3-d739-455e-a913-41d5a1dc8571,true +71f73b19-86e6-494b-8038-46a67396de4b,true +7227c5bf-3699-48cf-a0c4-fb8f5d50540d,"" +72619c45-9cb0-4abf-a98e-20cc49a4e4f8,"" +7287ec50-e64d-418f-a83d-0d3d93981f62,"" +728f469e-7a39-4a77-8118-944f83c2cf21,"" +72972472-355f-4538-b69a-23aee8614438,"" +72baabec-7047-49ff-9e67-338361a06e5f,"" +72dd2d03-e239-4a2c-b509-769886057217,true +73364971-4250-436d-b85e-93df377b2911,"" +734b53ff-038a-4c79-91e5-c14340b43145,true +73fe21cd-4493-4afb-ba72-376f75bc2469,"" +7409225f-77a9-474b-889e-38eb4db0da2f,"" +74556136-3dd8-4074-8e26-160ae1b5f780,"" +748bb216-e420-46e3-9aef-6fe6b2020a74,true +74cfd92e-5da2-4fae-be59-1546f5a22e35,"" +74dbc21d-e056-4050-8f0f-04194ac43995,"" +74eca765-7327-44ac-9868-ed01c1dc163d,true +751225c7-3a03-40d5-980c-89f6020bc2ca,"" +752045ea-d278-4939-a82f-3ef29dd7616a,"" +752b713a-e049-403f-9d4a-f560ee0d4681,"" +752f97cd-9398-4830-ad13-38e26e3a8bcb,"" +753ae998-68fb-4917-93ed-484ef1753d9e,"" +75509cde-925c-4645-9a91-c1f244863842,"" +7569ce07-0cbd-4a30-bab7-d5f482a27883,"" +75969f3d-bddc-4e9c-8872-a33f108027a2,"" +75a6eba8-9d1c-4de1-b084-00a5aff10eab,"" +766ee5bf-c1a3-4837-8ee4-0c81e7252c91,true +7690d499-c3d6-4092-89b7-81b3425164be,"" +76a04620-5da7-4914-a5b7-5a8506221f16,"" +76b1d775-0f28-4bdb-b6cc-a2441e8e17b9,"" +76cb0eb7-3679-4104-8121-9e01d36de541,"" +76d885d5-454a-4541-8ec8-61f7972f17f7,"" +76f4f348-f65f-42da-a338-1e1f28df0ffe,"" +770f3f03-8a4b-4e32-8443-49b14d54ad3b,true +7714ce28-a83c-48dd-a84c-ba3565432818,"" +7728c15e-82ee-48c2-90a4-afa79e048a52,"" +77293357-c730-4960-a8aa-c25ea0775c3f,true +773da43c-fa5a-4a21-85c1-724b9d72bbbb,"" +776cf7db-0b09-48dc-b089-2d24410ed4d0,"" +77a645b1-5231-4486-8f16-0470ecc3e49f,"" +77a7196b-7391-4a38-89a1-e01b15e9e2a6,"" +7879670e-7953-4dc8-86ce-88f346cee653,"" +78a727b9-5bb5-4ed3-aec3-a3f804c79734,true +78bfe231-0661-4502-b18d-28c24b223dce,"" +78edeaed-91f4-4f03-ab2d-38b720e5e6df,"" +7914b992-59e8-4541-8250-427de113802f,"" +794a6b0e-1e0f-4c12-ae52-47b53f385a03,true +7957634e-ec90-46dc-9779-fb000649bd40,true +795d85f9-c2d4-4219-8e06-f6fbcef30e33,true +7968bcd8-e538-443f-b4a6-e41b9766965b,true +797ac9d5-9ef4-49bd-af56-1bd0c971467e,"" +797d8c9f-56eb-4487-ae30-5c4dca379bf9,"" +79813005-389e-4671-850d-b9a5fbc2345d,"" +798cfbc1-a7b2-47cb-91af-43af0ae0119f,"" +79a428bb-83a1-4338-a613-9b732f6feb4d,"" +79c5ee51-42c7-4fc0-8e8b-7ce9acb5133b,true +7a281b03-7145-409f-9c5a-c45b6e544a4c,true +7a543c90-f6bd-4343-8311-6818c3a9066e,"" +7aa8cd33-8365-4c53-ad1c-e07dcf2f86dc,"" +7ab27dbd-f952-44d9-bd9a-f67d5790fc82,true +7b4255ec-4801-47ee-b12e-4b874c5eec1d,"" +7b8c6a88-3a53-48bd-9b73-bdc3f087e6b7,true +7b9a52de-eb76-473a-a622-4b19d50b6bc9,"" +7ba6211d-542d-4508-96fc-712328eefc69,"" +7bb75949-ef13-4934-a19b-798f6a5e7866,"" +7bdf88dd-7924-4b93-9ff3-d543a170e0d8,"" +7bf5b1d8-3edd-458a-9730-187ac6738857,true +7c197c69-7872-44cc-93bb-c518b8403da2,true +7c6c40db-df29-4b8c-8881-3f1765e51c2d,"" +7c6e1d99-bc80-4172-b76c-226f6a618b48,true +7c85bdf0-7156-4555-aa37-49e4195ce0e4,"" +7c94eac0-d189-4107-9443-452d124db20f,true +7ce02db8-4ca5-42c9-afe5-b818e42e1767,true +7d4a09ac-d7e0-4675-a9f0-313c73fa7906,"" +7d83ed97-4c6b-4ba0-9dd2-423f59e8bba2,true +7da3d62d-56ee-4707-b036-2c1b5e111aff,true +7de9fea9-9923-4dec-9c83-1cf13b81ca39,"" +7df8f003-7458-4083-8ef6-20a049526c19,true +7e194149-713e-46fb-ab75-4a7cc2acd94f,"" +7e618ba1-1acc-4c2d-9b80-fee3d12884c9,true +7eb4427c-1b25-405e-8ef1-38fabbfb1a0d,"" +7ebecbcf-c963-4cae-9b1a-8fe44e175008,"" +7ec8d0b4-41e3-40c7-8f18-fa10b249e023,"" +7f054bf1-9bff-4ade-8841-ebc67d4299c8,"" +7f35f61b-9551-45f5-9641-c9a74d7ef110,true +7f8f71fd-602d-4ce0-ad32-211f5e7ca765,"" +805e5d13-6a31-405f-b43d-3449d73a50d3,"" +806085ba-3993-48ca-851b-a5dbe0690926,"" +80aca9f1-6907-4658-b0e4-bf6f53838148,"" +80e8b1f5-ea5b-4abb-9a06-b51bcce673e6,true +81155341-1ad4-4473-ac14-9257704203e4,true +8118e76c-1974-471c-9cf9-0b31ed231efd,"" +8131895a-c6f1-4b0c-aba6-cc3a52066646,true +814970aa-0552-4357-b958-d572f56421ac,"" +8177f823-7335-4da6-aaf9-354e05299d71,"" +8197ccde-83c1-4ab3-bf4b-e849667f1f31,"" +81dd2be8-9b50-4d63-bc4c-22c4dcba127e,"" +81f1e8f4-a335-4910-8a27-151141514c39,"" +822dee6c-337f-4a5a-a22b-7de9e64d1144,"" +822e3fd3-ae35-4e89-a5be-feac7c6f62cd,"" +8242d422-fa39-4374-85c7-5d267d68a0a7,"" +826cf99c-9d92-4cef-b717-d5c16ea7525c,true +82e58dcf-ea72-4a50-9eab-a74460d58e4d,"" +82e8a61e-9eb4-4fce-ad43-881202cdfbef,"" +82f09a48-3b8f-4a2b-9067-61b51d85c500,"" +830df854-5f4b-474e-9aef-e7be6b452a92,"" +832e240d-da2b-4658-b638-cd2cf2f08912,"" +83648485-484e-46b6-9a11-64a48fe471f0,"" +836f63ac-40e4-4170-a9f0-f170c4654db8,true +83b971fa-bf7a-49bc-b1d9-09680e8eeb24,"" +84a15a42-428d-4092-9f54-235b55b11de3,true +84c41fdc-0d34-4d95-8999-7677e4235e5b,true +84c90e57-2348-4843-a557-444e3a82ce43,"" +84d36e49-fc69-46a1-a5be-e9842e8e192f,"" +84ed43cd-526c-4055-9422-c31dfefa43ef,"" +84f38578-0070-46e8-809a-65c75623829d,"" +8502fd55-eeba-4c91-8274-4f34dfe89977,"" +857895a5-3a82-45fa-9fc0-00380ef01b47,true +85827568-1a34-42f7-877a-99a2d3a0f5c8,"" +8591ca33-6c89-4352-adf3-8261ce1bf58e,"" +85ea993c-f6d7-4b7f-836c-3c76206d66c1,"" +8644762e-70c7-45ba-a0fb-92fdb9e6c73b,true +8668b20d-ed68-4d67-91fe-d35c385a3408,"" +866bd41c-debf-4a53-9108-fd9c0784103c,true +86786682-7825-48f0-bbc3-3b1a127aa654,true +86859d13-26a6-429a-a38e-be69f1af9b4d,"" +86946982-ff92-46cf-b6cf-caa45ba4a986,"" +86bc9f92-f89b-4fb1-affd-093a785ac1db,true +86fee3a6-5135-4265-8c8c-04ac00ea8e12,"" +87061f96-823c-4e0e-9dde-8034682651a8,"" +87346977-9c76-4d76-b8a7-23ded71369a2,"" +8746d3f8-1943-4ab0-af49-f7d40aad5cc9,"" +875be020-8c24-450d-9ddf-f642e60e62f2,"" +87e5046c-332f-4ab2-b8a9-ab15cfa91fa5,"" +88274e29-0d4c-41c2-9315-f96c93d44c0d,true +886a561a-e64b-44f8-bc77-76724e0c369d,"" +888dfba9-08c4-4048-bb9f-23fe80dfcf5f,true +88a3a7ea-728e-4bbb-be44-73093e564cce,"" +88aecc11-264c-4a3e-a2b7-94c99d39fde7,"" +88cf49a9-ec8a-461c-87bb-003866a4e28e,"" +88db01b2-8bcd-4671-9447-f466279f21f8,"" +890cdafa-a6ba-47df-9cc6-5ea4d4febcfe,"" +893f9661-bc71-4f65-83de-6483e73bbce3,"" +8979e8fc-9f34-4305-80fe-122fc619c7dd,"" +89cefdfd-b6d9-41fa-ab28-50563fe44a74,"" +89da332a-d11f-4f77-977f-6275f337495c,true +89ee0500-71a0-47c2-a59a-1b681d9a92fb,"" +8a31ea5f-804f-4b8b-8f91-6ac4bea2c4dd,true +8a56157c-ea64-4f80-81db-0c89a9d0b547,"" +8a5eacbe-4ee5-4e3f-9a0d-d0d1a13ae2ed,"" +8a8432ce-47e9-4fff-b71a-3147ad298fd0,"" +8ab69964-40a4-4d5e-8d2d-82d07174989c,"" +8ad34764-84db-4613-8483-4e8281f8f984,true +8bbcf675-5176-4df5-bbeb-38603e8d9c42,"" +8bf02dec-bd39-4a1d-b074-e0ef2167b93a,"" +8bfb6668-fc94-4b2d-9ec2-3385f1780d58,"" +8c39345a-45b8-44db-b5f3-6b5914b3fd93,"" +8c492ef6-59bb-4ccd-bc64-48d58d3da475,true +8cda568d-3e48-4e77-afa1-374809ed3c3a,"" +8d671817-97a1-46c9-b23b-e3013f13edb4,"" +8d98567b-2930-47f8-ad39-759745179c38,"" +8dcdbdec-4dd9-4928-9e46-4f46fd6df9dc,"" +8e1303b5-0694-4bc3-a0f1-559d51e05364,"" +8e55e68c-f1ca-468b-b4f7-11c11c2956cd,"" +8e5ebd37-bb67-4c84-b9ec-3422ed7c3b19,true +8e9c8ff0-82b8-4974-91a7-888dce4f7f8d,"" +8ea94f05-b5b6-4aeb-987a-567f627a4216,"" +8ef5e898-02ca-4617-b966-d5954b2cf403,"" +8f051932-7f43-4faa-b3b4-c2254756c603,true +8f19178b-b9b8-4858-8f94-c0f1e6eaf2c9,"" +8f5f16b4-fcef-4a03-98c8-a6aecea249f0,"" +8f62568e-7778-4729-a454-369f5a3f12f9,"" +8f62ada0-3878-437b-aeca-d59d658ece1e,"" +8fc9a4e9-9ca1-4144-8cf3-032a5ed6bac2,"" +8fea3b61-246a-4333-ad04-78348cb59585,"" +8ff0c7a4-f1c3-400b-bb31-c66df4866cfc,"" +900405a8-53f2-4a6a-bb75-80e9725f3439,"" +90126aaa-1dde-4136-9be1-4e30e2c1b667,"" +90e6ec4e-bc73-413b-a07a-e8d3b675c027,"" +91357869-20f4-4e58-8237-5b028e1f733e,"" +915eb7b9-47d0-4abd-a424-29605ef5f497,"" +91874305-9f9f-44b1-bac3-28dc0fabd0d2,"" +91f7217e-5c7c-4462-9f7a-ad7234bddf6d,"" +929edb45-2558-4fe7-b87b-ad4a801a26eb,true +92e25da6-dacd-4d0c-9457-751bc135c126,true +9307ddb3-12ef-414f-beb2-62a145d3f63f,"" +933302fd-1717-4cef-852f-0bc28dcfea35,"" +937de252-6da2-4dae-a80c-8ef39c6eb99b,true +93851c17-f570-4055-b6bf-ff928624666d,"" +9389f1c7-bba0-4286-ab0e-73ca1430824b,"" +9391e021-6734-4c01-a6d4-a9e151e58201,true +93c74a74-55b1-4f45-8b7f-3a0442ea5006,"" +93f749e0-9ee0-4cfc-b970-20f1757aa207,"" +94b95bc4-3355-4881-93ed-5db3dbcabc26,"" +94c1cc51-4dc2-4dd2-8a48-b6793675a44c,"" +95accbba-6ae9-4e70-9984-235e7371234c,"" +95ce9659-ea2b-43a9-a6cb-0b85fb4d9a48,"" +95e68649-5482-4d3b-bc6d-ca77d83531a6,true +95f21d98-e820-4054-970e-ab04c6b0ef69,"" +960866ac-7fbe-4f4c-8a41-f5c6d756a394,"" +962aaceb-7115-481d-8496-5ee5d12ac43c,true +96526997-d779-49ea-999c-43bd07d250e0,"" +96a5c8b4-5c9d-4092-9171-03da2422df80,"" +96df629e-35be-42c9-ad60-2fe43dfba0f1,true +975a8040-5330-47c9-9bb6-13a1d07fd3c9,"" +979229e7-5022-4a8e-9f23-8673564bbf4e,"" +97bd3c96-d38e-4a46-9e9e-0ff3466b80a6,true +97d8b079-ffd3-4bfe-a1a4-da06038813eb,"" +97f558d6-5624-426b-b21a-6a92c463d004,"" +98216728-4494-43ee-9af2-930201bcf2fc,"" +9873061d-c9e3-48f8-9a27-6a92255869c6,"" +98da112b-cca4-4bfb-9b85-32accfe1d295,"" +98e90113-a97a-40fb-b6e3-dd5f2e646901,true +993d7bc1-e96f-477f-b7e4-ad8d25c59e94,"" +995d662c-8641-4089-bb52-417a2eaba272,true +996a443e-1ca6-4e05-b1d8-b84455f2412c,"" +99893b11-009f-4ae2-9ce4-c0db476800bb,"" +99929bed-454e-4131-8368-9d152ab1da8a,"" +99b31b91-ec68-4c94-b23f-2b75d9302cea,true +9a1f1ac4-3ad5-4ada-80b2-cc31176393a6,"" +9ab5ad8c-b789-482b-838b-6cdcbd184330,"" +9acec191-7d26-4519-aac1-b50e00f3a2db,"" +9ad11a61-23e0-4603-90fe-c3001fdc7320,"" +9b4a1f69-52d8-4c2a-9e8c-072f71c2bd18,"" +9b876e7b-aa09-4b8f-8c58-a0cab74580b3,true +9b9b76e9-88d4-4440-868a-c5b153c277d9,true +9be9764e-cac0-489a-85e7-9f3c995e7061,"" +9c3ab93c-6424-4402-bd4f-0f0f7dd2b265,"" +9c630f43-c0db-42b7-b223-607d5a9a39a5,"" +9c9cebe1-ea55-48c0-9edf-22033f5ebebd,"" +9cb03b1e-f448-4f94-8c42-7f9271202a1c,"" +9cc11154-43fe-4bbc-a9ee-c5b8e0158d51,"" +9cece101-e41b-4d77-be20-ae0c0cd2cb9f,"" +9d3c20e2-321f-488d-9472-5756fa061ca0,"" +9d415448-4c3d-40c3-b910-ee3ff0df9b3c,"" +9d495d7d-837a-4d3b-bb10-608f9abc919e,"" +9ddbf3cc-7d54-4532-a670-5c361df676d4,"" +9ddc0101-8632-4103-a12b-bf8c5590f624,true +9deb306d-e6ef-4bdb-9a20-c9f5ebc556d5,"" +9e1b3c33-ef02-48ce-9b60-15b62a9a499e,true +9e32e6c5-44d7-45b2-bb87-65e98f8464b0,true +9e3fc42d-d08c-4cb4-93a0-a567c5f6a19f,"" +9e5071df-d3ea-4bd0-83b7-e08ba3fbb896,"" +9e58de28-a944-4ca2-b53b-b8da836ebd93,"" +9ea9ede3-8f0d-43c0-9f35-cc9fcfb622e3,"" +9eac5165-a8e6-4acf-8d52-4ad49e2ba851,true +9ed868fd-baf3-490d-b665-113b9427520d,"" +9f078010-f724-422a-8d8c-8855f2513eec,"" +9f3630e5-1b35-43bb-b53f-c191634ba14b,"" +9fa9a6d4-e6fe-4eba-bbe4-7319b735c63b,"" +a0238799-d0f0-49a9-96b4-33cfc1688279,"" +a0520e0d-7dc2-4218-9176-32eb842de85f,"" +a05480c6-8b4a-4406-9226-8dce4bbb4d21,"" +a0eff999-b331-46a2-b8dc-16727efc7580,"" +a0f58ee1-6e61-41a9-b0c7-5acdb005ac0d,"" +a1007ed7-d907-443d-813a-0bbb0ed84e50,"" +a1155987-73aa-4d48-b127-5da6d4cb7b02,"" +a1bd990a-7d22-47af-8258-5d4a05b269a6,"" +a1e0979c-d57c-4482-9087-88077cf657f9,true +a2224a99-ae98-4018-8651-38f1f145c76b,true +a2466ef3-db84-4434-9e07-af11c15c7490,"" +a253f260-5b6f-40a2-b4cc-d2c66856ffcb,"" +a27b5fe8-3465-4b6f-b63d-cca66626727f,"" +a28cbadf-918a-4831-be0e-9ab6c83133d7,"" +a2a6355a-2c94-4da3-a707-cc6db6553ce2,"" +a2bf4c9c-46d8-41c4-8eb3-044e832c78c6,true +a2cb445a-10da-4b47-add1-16584c34d8e3,"" +a3240817-7453-496f-9d7b-058889858399,"" +a34042e1-cc97-476e-8564-382d941458b4,"" +a35cdf18-7bae-4776-8aaa-652bfc135af9,"" +a3b8ad3e-c982-4023-8977-e9717a33d645,"" +a3f4de14-3398-4b34-9165-3a24c5742de1,"" +a3f9fe69-1527-4d04-a51d-ca9f1955d210,"" +a452f6e1-013f-4745-aa25-e2cd16ca4423,true +a46ec80d-9cd6-49d6-863c-5f5425899445,"" +a49f38eb-8de7-49e1-b7de-97ab32fb277e,"" +a4b245ca-a50f-4bb2-ad64-1124c31eb166,"" +a4d85c0a-4687-4454-89be-085b9a2632f9,true +a4fec49a-dc46-496d-86a7-5387c2490c3b,true +a500b66b-fab5-4ee9-bda7-11fb6170fff0,"" +a533451e-9e8e-448e-bc5c-1beace2c397c,true +a5a464c0-3b64-4ccc-bdb4-62aac198eddc,"" +a5c68c36-129c-482e-a9eb-023d7ec1ef0d,"" +a5d76237-0ea6-4016-91a1-33463ef1e9e4,"" +a60eddcd-ef19-4a84-ac8f-9206ed2aeed0,"" +a618792b-5b12-4545-a3e7-c07313d188f3,"" +a65e37e5-cf18-488e-8870-e4aeb021ee41,"" +a674a795-2553-478c-a5e4-6fbde13d7523,"" +a67aa655-62ae-4905-8042-30fd3ea68944,true +a6a1fe2b-4322-4ea8-9ca9-3bcf288afe36,"" +a6d86605-7084-4477-8c8a-8cf25c4d1b9b,true +a6fbb09b-5b17-49f7-a510-5c1596b424a3,"" +a717a4a4-b0b2-4aba-af9d-7b431e7883e2,true +a71de636-d8aa-4455-ac06-932ae6d848ee,true +a7575150-4148-4b9c-b941-64db8cc61356,"" +a769b6ce-379a-4f6d-ad06-5df3a58d25ff,"" +a7a4ad54-167b-4cc8-8f88-dcb555c9dfb4,"" +a7b38940-3cd3-43b1-bba9-6adb6090d1d3,"" +a82170ad-dc53-4899-a7ee-cdbb50e6a91e,"" +a83fed45-f814-46b9-9fdb-50892a1a1736,true +a8624bea-ae5f-4fd8-b6ed-11b0fbba9254,"" +a863d462-6836-4f42-a4a7-8925574b76fd,"" +a8c9520b-bfa8-4915-bd66-a6133e1c5ffe,"" +a8f862f6-2e8b-4cec-81ab-eb3be51d71a8,"" +a906f033-5f9b-4c1e-aaff-287cffc6cc7f,true +a93d01a3-5bc6-40c2-9895-64a21fbd6253,true +a9584e1e-deb8-45f9-830c-bef1caeb21c8,"" +a961ce1f-cf0e-42f7-ada6-f283daeac650,true +a972425d-8c4b-48ab-ae2e-fc7db6661f67,"" +a9888a76-f2fd-4161-9d15-6126ba398899,"" +a9b103bc-f890-4d91-9714-8d674aa842fa,"" +aa5fe96b-324a-4010-b128-a5063ce0be77,"" +aa86bd26-a862-4a03-9d8c-a04ec4c70c0e,"" +aaada565-8a59-4f69-b92a-a6cd9a323a24,true +ab3e98bd-050f-4bfa-b6e9-d829291290a0,true +ab50086c-5cac-4c6b-8e71-6988453228aa,"" +ab52bac3-d430-4700-b1e6-7efe2f5613da,true +ab63c859-8b0c-4874-9404-cf7c89a368e8,"" +ab8aa7ee-f65c-4a29-9995-ef33c4135035,"" +abcfc7ff-d824-4414-a586-3c33c263a990,"" +ac139e4b-9d46-460e-92d6-0ac43ce8cb67,"" +ac5bafbf-2bfe-4dc4-8e13-adb2d80e8dee,"" +ac645c40-0c51-4d77-a5fd-32e619019c60,"" +accb0b6f-b012-42cd-9374-91355ed49aa8,"" +acd3b2a0-1a81-4738-9bbc-9ab0c56b0a85,"" +acd69c03-a3c4-44fa-b3d6-749476309db9,true +ace8301d-b547-4cb2-8311-e27a8980633a,true +ad07d661-6987-4928-93a0-e7b902b24ffd,"" +ad2a1d8e-6e19-4d5b-90a7-ab24050735a2,"" +ad48d6a7-890b-4eba-919c-ff6b63e35304,"" +adad08de-aeef-42cc-9a2d-b99fab5ab1dd,"" +adbb15f3-b71e-49a7-a954-2f117a93b972,"" +ade38b82-c9cd-4a9c-a7f6-23130baac87e,true +ae13da32-7194-4f04-9fd5-c7f114a2e5b0,true +ae4da701-069d-4ede-b59f-a2524c6529f0,"" +ae52de8a-deeb-4144-bfd3-52c2cab5fbb0,"" +ae56f2bc-f7f6-4bc3-ad8a-3b1193e40f71,"" +aea61272-bb6b-4fab-9817-584a8fa2f55b,"" +aec815b1-23cf-4504-8576-fe03b8798092,"" +aee86188-c252-4910-98cf-a8d3ca9d029a,true +aef2f04d-7449-4088-9ab5-a227d1d7c36d,"" +aef45e8a-6923-4db5-9bb0-18f472f7f0ee,"" +af12db23-5b03-4e68-9127-acc14775690a,true +af52f728-fcd9-464a-9e25-28013b84fa1f,"" +af73e4bf-2ba0-44ec-b619-a04f1c13c9a1,true +af77032e-b1e1-42c5-8540-68bcb906f134,true +afd2cfb1-57b0-44ab-a8f5-6edc92bc870b,"" +b0138fc8-736a-433d-831b-0bc39281d67d,"" +b0525467-772d-4d5f-b326-095fe72890e9,"" +b07bd4e7-6586-49d4-9f43-19d58889743f,"" +b0a1b45a-9dfb-482b-96d4-362cd1ee625a,"" +b0a510f8-2c98-436d-841a-eee086eba241,"" +b0ad5c48-9538-493c-b5a7-87f8f5ff858a,"" +b0b8b0c1-8184-401e-9346-37422a6f2f81,"" +b0d0e0b3-acc5-4887-a39e-df765111f99c,"" +b0e1d515-5be7-409a-8c86-3aab8ab6787a,"" +b101ebeb-ddbc-4bb2-b5c9-2bc6a23e0a16,"" +b109fc82-447e-4d4a-a447-1c7f0569bbc9,"" +b12f7f41-f8f8-4eb6-b2fa-dd5a18639c11,"" +b155b9d3-54b8-4906-a564-601bf123f027,true +b18674a0-77ec-4d7a-b563-aad0856ce45e,"" +b2071f60-d582-424d-b873-9ea4c2615442,"" +b217ba96-19d5-4184-a1ce-890bfdec478a,"" +b243e613-8498-427d-bc20-acc54786ed44,"" +b2503fbd-507b-44db-b4d0-32700a3ba5f5,"" +b260cc9d-644b-4e25-a99e-9afc44dc3879,true +b2766451-0904-4ccb-90c3-fa7fcdbe19c4,true +b2b2289a-0762-4846-a4a9-fbd7dc1a3822,true +b2f8bfb5-d8a4-4df9-8724-bbce63e4dcdb,"" +b3394219-debb-4c75-988e-98fef99f0500,"" +b34ef85b-d2fd-4fbd-bb2f-6c21d737e21a,"" +b376a344-8079-4b95-99a9-d515f9dfa4a3,"" +b379efa9-29ce-44ad-b653-9cc03ac2bfe6,true +b3861c55-ae00-4319-8a76-03627b8c8bf4,true +b42a782d-79e6-4276-9fa8-744d5d1bea24,true +b444d377-d1b0-4eb3-aca4-c24d3fac8c37,"" +b4771fd0-758c-413d-bbc2-17e8e2cc79bd,"" +b48e7fa4-1922-4d4b-858f-a4f3bd8810a0,"" +b4a9bcfc-73ae-4798-a221-bbfe9991e0f0,"" +b4ce60ee-7591-48eb-81ec-0466d931b2a1,"" +b4f80b37-afaa-4974-9cd7-f53d788b2be0,"" +b508dc50-ca89-4b92-a12b-b032d3bf3a5f,"" +b516b7eb-4029-454b-a8ec-9bdede40ffb7,"" +b55a959a-73e0-4b7c-bb03-88bb22844c09,true +b59c5c8e-7d5f-48bf-b3d8-900e18a64b12,true +b67c717e-f9fc-4ec3-8cdc-ade1c8d1b95f,"" +b6d48a75-7d74-45e6-9fb0-154ca5264744,true +b6ed4e6f-6911-4cd5-92de-f50e8d1916e4,"" +b7289502-ed78-469e-8b73-04811493a484,"" +b7597773-8d3f-4ee7-b54a-6c8b60b6d47a,"" +b762619c-c328-4367-99a9-41f10751cedf,"" +b7d87d24-1805-4a12-8f8d-2d14509d5eab,"" +b7f806c7-6ed8-4b7c-bf42-dae336e3f7b3,"" +b80e31af-6b74-4685-a83e-50c5d7f762fe,"" +b862117b-c899-4938-9df3-6baf43911d1b,"" +b89dd640-c21c-413c-8774-f9a154d897f8,"" +b9578448-2338-4f49-9d63-5b886a537f07,"" +b9701217-a4ec-4ef4-84f8-49ae5825b45f,true +b97f2f71-17ed-4e3b-8e3c-374241e6faa6,"" +b982af8c-9e7b-4dba-ba74-76770efffefe,"" +b98be876-6fcc-41e8-ad4f-a78b1661acb1,"" +b9dc5e38-47af-4d07-8ad1-b0425c5cb386,true +ba047f08-841c-4d5c-8f98-b3e614906d17,true +ba5a0e2c-6e96-44d3-800a-991a81337994,"" +ba7bf8c1-e6a4-4437-b1ef-cf9e443971d0,"" +babdc581-4c93-4674-8743-1be4b18ba156,"" +bb182025-e149-489f-b69f-debf6907da09,true +bb2c53fc-6d97-4747-a60b-8010f62b7f63,"" +bb770b6e-11d2-457f-858e-2e2c6c86c0bf,"" +bb94d817-e843-416a-bc31-4858001e7976,"" +bb9c95de-6073-4239-bb5d-023d18344157,"" +bbcd2900-31df-492c-9d43-e8e0243f7e1b,"" +bbe0b9ec-5a6a-44a9-9770-fbe4117593da,"" +bbf5580d-bef6-4cd7-a231-b6a532d68aed,true +bc1bab6f-5d84-4c95-afa7-b4ab39038ced,"" +bc23a56d-f42d-4bdd-b704-07376d4a24af,"" +bc6abddc-4fa4-4ae8-97f4-9c566558b227,true +bc75ec01-01c4-463d-b64b-597c106d4eac,"" +bc929bf3-06ac-408b-a17f-6ecdb28759a7,true +bca14431-d108-4ceb-831b-b6cedb7b1b22,true +bca1f5dd-414a-4570-9f0f-ed733bd170f6,"" +bcec2bc4-4e04-48cf-b52c-8e1fa2ac3875,"" +bcf5154c-180c-4366-836d-13aa6bfce980,"" +bd3b7896-2b3e-4c1a-a2b0-aca1c2ea23c1,"" +bd687828-857d-440d-836e-5230d3254b1c,true +bddfe37f-fb3f-4a24-9ce9-181f250aa0b8,"" +bde29534-91ef-4817-a1f0-00a5cc9475bd,true +be196f96-4e26-4c23-8241-b0a10a39e831,"" +be1ca606-c535-4751-b52e-c61cfe9b6c73,"" +be3057cb-9635-4a25-863f-b4e79cda75c3,"" +be6d80a5-e2df-4e99-9721-80097129bd8c,true +be7a093e-d70a-4a23-9db3-bd95aca334a6,"" +beee46de-ddd6-4fe4-80bc-6f1f4b8fd42a,true +bef4846a-ca76-4000-a98a-00a9d327107d,"" +bf88c593-87b8-46d5-808e-8a332c5b50d5,true +c015fb2e-4062-417d-86be-681d98f8a13b,true +c0381889-4401-4bc4-9056-641340fa7ec9,"" +c070e6de-9ae3-42fc-9cf3-023839ad0442,true +c086a87e-ec86-403c-8bc6-37a9b77924f0,true +c095cfbf-cd84-4681-ba67-7b3ed318186b,true +c0a2c5cd-58d4-49ca-baa7-d5859abc680b,"" +c1003a14-56be-43d0-9aed-41fb6b048273,"" +c1370f98-3833-49d3-b58a-21c581ac4ab2,"" +c14127c7-9943-471c-b5c8-ee9f0bb95bd7,"" +c1d430d5-32b8-4410-a1b5-6212b2c411ec,"" +c2253c94-aa7a-4e88-8410-e528b08654f2,"" +c24b807b-174b-4e5f-91d2-93599fb21548,true +c25d3d58-1f6d-4004-85c4-3a162dbf48ec,"" +c286cd77-3c89-446c-a91a-4769aa088be1,"" +c297cce1-5d10-48da-8ef9-e860ac55f387,"" +c2a32eca-f03c-4fe3-8c29-3b69c9798b5a,true +c34d92cb-7086-40e9-b303-97e204d2ab4a,true +c36767f9-a3d8-4f57-a370-4a088ea0b023,"" +c37a2b82-a495-4d05-8f8b-99a757d0b83d,"" +c391f109-1259-47f6-979b-e72492709b66,"" +c3aaa4df-ead6-4a84-982d-3c28752e1070,true +c3ab4714-5eda-433e-b461-c1710b769476,"" +c3de8ca9-c03a-4689-8701-dd524884b5b5,"" +c3e98495-15f0-4040-b92c-31aa40235dcf,"" +c47474bb-570e-45af-ad38-8f5352ee3774,"" +c4757dc4-d69a-4e2b-9b8d-61353a5b21e7,"" +c4e0ccb4-df43-4b20-873d-3a66faab42b1,"" +c4e31ea7-6ad0-42b7-8579-c3b7fcafa740,"" +c4e6e6bd-2135-47e8-81ae-7e1d6d5e7482,"" +c4f82d4f-f53a-4d32-bc78-67aa7786ed1e,true +c52dbae3-07a4-4039-b04e-d79a86941c76,true +c52de404-7bbd-4b07-95a0-a66df22a3221,"" +c533b9cd-e56b-4e32-93b2-1189f37eb646,true +c557b460-3e1e-4ec4-9b4d-ea7bc0c8d64c,"" +c5609af5-9f49-49f1-80ac-b18fccbc9720,true +c5f20b88-cbd1-4283-ad46-5b0bf31fa3ba,"" +c6386600-4824-43b9-b366-4504f4e74d66,"" +c6442145-3aad-4b57-b2cb-b7eff0699959,"" +c6700fda-f009-496e-83ec-0532f34bfa92,"" +c6a0f008-4d97-4319-8099-7e0cb6708438,true +c6a3be9a-b061-4a5f-879c-e948aa895f3a,"" +c6b44473-ebbc-48dc-8a42-44b7da0de840,"" +c6cb9c06-0c13-4cd7-8d20-ca7b99f7d141,"" +c761f0d9-c918-41b3-9131-856aad1f5b2b,"" +c7e313a6-4659-4fad-9402-946879a91616,"" +c7f263ed-22de-479e-909b-f6ceaf5f2eb0,"" +c80ab964-cf3d-4e89-9232-8e787cb0def5,"" +c80ec189-5f9e-4049-922e-969d28b3bdde,"" +c837974e-0093-438d-a822-19e97249f0dd,true +c895019e-6471-423d-ba15-4f06ed628c7f,"" +c8bbf035-8a01-4c57-934e-988a584c98b9,"" +c8c936bd-3e6e-4500-bbd5-051659c59309,"" +c8cb1ae0-6a31-4869-a396-78dd5dc7f302,"" +c8f123b5-8e57-4c9a-8770-bd4b4c2c064a,"" +c8fd40e1-35fe-4c8b-af6b-730fd6fb5fab,true +c92a4616-7215-4ba1-99df-40aea82eedc3,"" +c9445880-656a-4def-ad1b-2a4200d76c13,"" +c9647fa4-976a-4d9f-9be4-26b9c71f6eb1,"" +c98372ea-e9ae-4438-8715-b54ccdcc8f30,"" +c99c2510-b392-42ee-97e1-16f6a3b50978,"" +c9cd4daa-907f-490d-b3e5-a43eedd74c32,"" +ca45fe64-e7c9-48ea-bc02-3bc6a0b58e46,"" +cab21bd5-4314-4bb1-8b16-0967f8b08757,"" +cab53124-f25d-4b4a-a238-3d028e788b2e,"" +cac06963-2da1-4935-a6c3-d6152132c7eb,"" +cad24afe-7131-4158-9153-742c9fd16c9b,"" +cb1c6a1f-e659-4fe2-9cfd-f28e776a4f06,"" +cb5c302b-35a6-4d8d-8d6f-72ad1a3ed1cd,"" +cba58256-d558-48df-83d7-be5939d6dfab,"" +cbafa157-0905-418d-983e-827cc88faa94,true +cbfd98df-8ac2-4497-988b-bc4d1c9c6095,"" +cc0b8f72-76dd-4eaa-84c1-c343982e18e2,"" +cc1e584e-6752-4bf3-8c51-ac0192b5df44,"" +cc372f1d-a83f-438e-8d8e-c346eb03fee6,"" +cc38b529-3137-4d89-804e-51c6bd60ca97,true +cc3a3e25-87b0-4012-869b-9905b31f8319,true +cc5fd0ac-6ce5-43a6-bb4a-67279156ee8c,true +cc7e521d-4fa6-4215-942a-48f84ddf9a49,"" +cc8ade38-d9f1-4700-aad3-dc866f35d1a1,"" +cca1c9e8-c68f-4fe0-ae79-693399d8ee31,true +ccb56a74-40db-4d58-b0c4-cd485e8a7fe8,"" +ccb810a0-28a5-4248-92dd-7259a0fa0c22,"" +ccbda4c9-3ec5-46c1-a8d6-a215651dfb43,"" +ccbda933-c3d4-44bc-acfc-fd26bc234bb6,true +ccd5afad-8f2f-4305-b646-26137eff0a0d,"" +ccd69a01-cd72-41e7-87b9-de8454411ee3,true +cce63ba1-abd2-45d1-9ba0-a2cd0fa9b00e,"" +cce6dbc6-3a49-4f8c-b908-e6f11be81ac6,"" +ccf36cc5-5009-4fbc-8e8e-81f38d3195a7,"" +cd013d11-8609-41d9-a9c6-7fb33a499f51,"" +cd09f5d3-c846-41e7-a1ff-aabb55973663,true +cd2c3f78-ddb1-45f7-9939-987e070d9414,true +cd3d18de-96d3-4132-ae73-b80795a53ad0,"" +cd71ffde-9d7e-4c27-bc22-306f81cb46b7,"" +cdc96f77-a589-4ae4-85b6-c6d2c89487ba,"" +cdcad0ef-8049-41c2-a8ee-21835323b05d,true +cdcae470-3531-4548-a2a9-ba665fca8930,"" +cdfbf7e0-ad10-4c22-9ee4-888bb6bdd198,"" +ce1b7543-fee6-4267-a00d-daa5a5ea2861,"" +ce225925-36ec-4c1c-a327-c64a146bef46,"" +ce512c4f-3808-4ef6-9853-6f7d14e146f9,"" +ce7037fc-2614-46f4-a8db-40a2a0f9e3ac,true +cea2e600-da22-42b8-aa08-f0e951ff35d5,"" +ceea3ce9-5ab6-4cbe-99b2-34ca9e6eb468,true +cf17f19b-9f66-4391-bd2c-55384690d9bf,"" +cfced5ea-1e8e-4c85-8318-ef91a041f4e0,true +cfff2bee-7cf4-459f-8690-3638266a07e3,true +d000b381-5ba8-4a5b-84c7-f371e104eeaa,"" +d012051d-65bd-4a59-b4cd-f454d6010888,"" +d05fad91-9a3d-4d8b-ba99-5a33fcc82081,"" +d083a1aa-9662-482a-8192-4709f904f16f,"" +d0b22c1a-d0f6-4d83-bd3c-475a3acb0b83,"" +d0be6a2c-ebc5-405a-a2a5-006a5ea52c76,"" +d15e2267-a699-4f43-96a3-e98de7ace044,"" +d168f31c-483c-4340-a2f4-6a60cc8cab30,true +d17dfd97-60aa-4313-bcd7-f48935faa2e8,"" +d19385b9-bc04-4000-bddf-1d09425a2b4f,true +d1ba146a-9503-472e-b668-3686ff275ef2,"" +d1c2f4a3-8af5-4ad4-bd0c-032b947d3c25,"" +d21af0cb-c5a1-401d-b605-a2e3ba3f46a1,"" +d2272949-75dd-4949-88fc-f0f157c83105,"" +d230ce54-d5fe-4983-9e91-519ce1249322,"" +d241d156-478f-47a0-989a-96a5fff36780,"" +d2663716-cdce-4d88-90f8-51fb5d59aa4d,"" +d2a3d703-44e0-4dee-a8bf-9fc0457841ae,true +d2c11b5d-93c6-4500-bc4c-8dc50057f362,"" +d2c4f328-e7a4-4d87-b180-9a0eee13d165,"" +d2d08017-f955-4e0e-baf0-2d5d37acc304,"" +d31bee09-f02b-44c5-aa15-a06343e0bf9f,true +d355c55f-53b5-407e-8785-33e4e54bb3fe,"" +d37a07ee-5d7b-41d0-bbf1-331277662c52,"" +d397d6be-6008-47bb-9f72-628fb5c41cb1,true +d3997124-9e16-4df3-8c60-f43f62bbf036,true +d3e6de0a-bfef-438a-b982-4818145651b9,true +d3f2c0c5-1f4c-4156-8cc0-e2d87db500ea,true +d44741c1-d58a-495e-9f30-cc0f19fafc4f,"" +d46e0f9c-5dd1-4e88-9a22-96ca436674d3,"" +d4aa494b-3328-48fa-9873-39be6536a437,"" +d4dc8d84-20e2-4053-b244-47549e74680c,"" +d524b58b-90df-4d29-b4c8-308ac04dda2b,"" +d56569d3-0a16-4968-9470-93d410916f11,"" +d5944a91-3bf9-4915-8512-0f1f50a8eb7c,true +d5aa4b50-1ac3-48bc-90ee-7ad6bd78a078,true +d5ca4448-871c-4175-801f-38bb43cdb48d,"" +d60c26c8-1b83-4de9-be17-81fca1ef2575,"" +d6c622c5-3662-4b29-9180-0b4055afa612,"" +d6f1073c-bf1c-4232-8ee2-5b92f0a32d8e,"" +d702593f-4121-4ac3-bc3f-dae097c7a044,"" +d702f666-bb61-4d55-9579-e56efc3e0e91,true +d704d649-9e08-4502-a9c5-820f503dac9a,true +d7c0876e-3031-4be6-aa2b-bbd8e2bd8884,true +d7eba5f5-103c-4442-9a7f-62c81a9dd9e5,"" +d7f76663-5195-4de4-bc43-ee61e467fee4,"" +d8534558-7fea-4dcb-a1fb-2981b725dd61,"" +d86d32ef-f50e-46d6-b434-fd03bc807cc4,"" +d8a42c84-6930-4b12-8c1f-9a492d290454,"" +d8cdd01f-c8b2-46fc-8f69-35da565e1b99,"" +d909c299-c622-4c39-829f-415621e09eb1,"" +d94160a6-7943-496d-8b66-172e9ec6804e,"" +d97e5072-19d7-49bb-aaf1-f3a56816f3e3,"" +d9e59fa9-630b-4d97-aa71-4e03bd6fe1ad,"" +d9ebe2d3-2a6e-4079-8f59-43a327e68ebf,"" +d9fb7469-d50c-4492-8c1c-8bac1ccf81bd,"" +da33cd96-8f15-47f1-aeaa-846234a6b9cd,true +da412e67-cea6-4ad9-8c66-75bf7bd9d0f9,true +da438390-6d67-444a-be2e-354a21d30559,"" +da4c7a8d-c75b-4050-bbac-5edb50e48d4e,true +da5de060-6e29-4379-9119-175b394f9bac,"" +da98f3f0-236f-4c41-b123-09f1fdb5bfc6,true +daa0c0a8-91bc-41c5-9627-adad04a7b15b,"" +dabbe6e8-3692-406f-8a2d-f81217eb6964,true +dac01aa1-44bc-4ff5-b123-4868f8f278ef,"" +dac87128-5796-449e-85ea-2c1f8e09ba0b,"" +dad4c0b8-0e02-470c-b7be-6477008d925f,true +dae5b7a2-ad95-411c-9721-067d3c578262,"" +dae62ac4-666c-48f7-8587-ff9330a9e9e6,"" +dafa1e16-2149-4e76-a693-88d2e7e29a0a,"" +db0a2a90-dc62-4e6e-9a46-88b9a3145ab8,"" +db16da7a-538a-4270-bd0e-1b4398a922a6,"" +db1788c0-f515-419f-ada6-834a37168001,"" +db17c5e1-6d1e-4b0b-a345-8dca770e7097,"" +db5a6739-388b-453c-99d0-58cfce24d5d5,"" +db8a9775-faff-49c4-8b35-74e92245f439,"" +dba78a31-21c5-4600-b18e-3e90237ab40b,"" +dbbc9b03-4d76-4118-8637-185659ce2adb,"" +dbc0cb40-5e33-468e-bc9e-2cf8ed602d01,true +dc2a8c49-ac89-487f-a22c-dc126a5c7ed1,"" +dc36732e-8054-4d6b-a860-e7c54f04a0bf,"" +dc567aee-5073-493e-bec1-b6b0f4e160d5,"" +dca15405-893d-4468-84ad-574e54f45c22,true +dca8db58-f563-4a61-b747-94f5ec5bf135,"" +dd09736a-85a6-4c2c-979b-f2a7027308d1,"" +dd9a2411-d45c-4385-a6cc-650df658ae9e,"" +ddccfc35-d71d-4e65-afd3-4cf2a21e607f,"" +ddda9bf7-d645-40a2-8aed-eb9efa425d01,"" +de1c574a-a49c-41d2-b321-849c005c89e0,"" +de81cdd8-a6ed-4ed7-af7b-6ee027d0d5cf,"" +de9bffc9-c6ee-4ad2-8055-1e0d0e48887d,true +dea4f32f-0f51-4bf0-af67-e79b34674fac,"" +dee72459-d0ba-4771-af17-f38f8396adb0,"" +deee1173-4f31-4784-8c63-d02e2a7b16ba,"" +df471b44-cfeb-43fe-9488-8f85a03952fa,"" +df529c86-f229-404c-8f0c-44e1b29e4e95,true +df54eb2c-59c6-46cf-9cc0-201e94acc07d,"" +df6522a8-552f-4ba1-906c-139f58a0a85e,true +df8a0f98-893b-400b-9da4-2514e50c0b24,true +dfa10a30-82d4-433b-9df5-b0d2291378ae,true +dfa72495-2737-4fe8-9fcb-c799ab51ddcb,"" +dfb67b9c-64b1-422f-887e-139a8f676fa4,"" +dfb6cb62-17e3-416b-9214-6ae6f432874a,true +dfef1286-acc9-44ee-a736-b9676812235b,"" +dffc6fbb-8592-4f0a-8190-1e64eb2bc634,true +e0010996-fa96-46be-9431-ebbe139c081c,"" +e00ec480-db7a-4aab-84ab-7e5e7184bfdc,true +e0ef5017-54ab-469b-9871-f706d4899465,"" +e0f2d024-4210-4f18-82ce-51755627e13f,"" +e1309aae-d59f-44f0-b630-fc538bab9027,true +e134ed0a-49e0-4a0d-b09b-4e874f422e60,true +e16400e0-a6e6-459a-a16d-361a7b2ffd1d,"" +e1a9f42d-103d-4e01-b98a-e70f98aa1c00,true +e1c6ba82-6bc7-4f15-b71c-c669cb78bcc9,true +e1e4e2e8-1c7b-4c67-bc7a-3940e6670357,true +e1f9bb17-3719-45d6-b4bd-3be88f17e429,true +e1faaf81-1761-4a4f-b01d-c179db8474f3,"" +e20067e7-f2fb-472b-811a-3d28a08bf31d,"" +e2501541-dbeb-4e28-b4d8-598e963d6158,"" +e2b04908-769e-4916-bbc4-45ad7db85e02,true +e2eccb3c-0755-49c8-8e82-cc510481ed04,"" +e2fbc85e-dbc4-422e-9a11-0007d5c194ae,"" +e3784666-7f48-455f-a137-e6262a617ccf,"" +e3c2c69c-bbe5-4678-aa6c-3e5c7ff996f2,"" +e3c5df86-3d35-4dd8-a081-48632a3b67c8,"" +e3c94ca7-a487-468d-83f2-8068a592a774,"" +e3e4b2a1-6c40-4f42-a5b5-17b352209b40,true +e47d814f-5139-4339-a710-fe953efcfa74,"" +e484c47e-4da7-425b-a636-de512fcbc822,true +e50c31e2-5d52-4d45-9b8f-8ae3fdd26488,"" +e53c4c4c-976f-4cb9-95af-fb11c264cb72,"" +e53ec08c-9029-4b50-bc1b-a302878b17e6,"" +e562454d-7fbe-43a2-8046-bfc5b6ab043b,"" +e5803192-2273-43bf-8acc-945cc13af70f,true +e5c7eb1c-238e-4bf8-82bb-205c383f1517,true +e5d9ff02-57a4-4e05-b573-0dbc80e19958,"" +e5fa00b8-1779-467d-b881-757b6796d8b1,"" +e5ffe973-b166-4240-b5d5-17eaad746c4d,"" +e6e9da2c-7684-41fb-9123-def8a7cb4dba,true +e7098f3c-9dec-4aa9-9554-b3ad9a7d842a,true +e73f4c39-965c-47ca-adb5-0544e20d45bc,"" +e757ee7c-a50b-4575-b383-587e6f782bed,"" +e780a3b4-6b8a-40a1-a9ba-5f95725399ea,"" +e78c789e-7b81-49ea-b7e7-d17d8e8925aa,"" +e79745a2-654a-46d6-a886-dd1d21acccf4,"" +e7b3ee1d-2d5e-4dd6-8ae0-ebddf36aee4d,"" +e7d53c39-4adb-441d-a4e1-50c5f60fd3ef,"" +e81ec213-328e-446b-9c33-ee80bc850d44,true +e83d90d6-c694-47fc-8120-e91546fdda8c,true +e8ba3683-aa88-4800-a248-737d39ecb6c6,true +e8f05409-642b-419f-8475-28449c5f9569,true +e952a654-0605-409f-ac45-19d00d4b53c5,"" +e97e9781-3cb3-44b0-89a9-b704d456fcc2,"" +e9ab227b-2a64-4c48-a8a0-6c166bf4b970,"" +ea2f0657-1625-414b-9c7c-bd0b01a12eff,true +ea91b2ad-37c8-4a4c-9178-11d7a5e4e75f,true +eac7851d-1d61-4a35-9f08-c5da53335f7f,"" +eace08fa-4018-40fa-a7fc-3daf10b2f21d,"" +eae386dd-ef2b-4629-817f-6f8c44ce5817,true +eb2419c3-3b91-4d73-b4be-a40e759ab957,"" +eb2781af-72a5-4760-a9a7-20d212f56230,"" +eb511148-31f2-4292-a83f-d16d3be6631e,"" +eba22453-8605-43d3-81f4-f703e58a230d,"" +ebad9165-a532-4846-aff7-5038cd5c694f,"" +ec3d7e48-c9f4-4f64-ada9-7e2891a62d1b,"" +ec462f5c-2aaf-45fa-8c25-6f556349af00,"" +ec4d4a14-0934-4d28-ad20-64db8fe78d42,true +ec9ccc2d-1e6d-4ebc-b1e5-86d493d19eb4,"" +ed352845-d1af-40f9-afca-53503a6518d8,true +ed7a65e1-de6f-4c2f-bd47-aa78d0c2189c,"" +edd41c4a-a5f3-4531-b506-d81c04e1ebc6,true +ee004b78-c05d-4c34-a9f3-290a9259d3a3,"" +ee6749cf-0622-4376-958c-229ebc0f9618,true +ee8905ec-84b9-4fa0-b1b5-0908206b7af9,true +eeaa2e25-739d-443e-ae83-b0ef04e2836f,"" +eed7cb9f-7fe4-4f9d-bb4d-cdaeea6e144f,"" +eeeed70d-3cc8-4b11-9f6e-ab44da414b90,true +ef079a39-9f59-4681-91fa-3d745c5eaec1,"" +ef10cf22-bdb9-44b5-bc9e-bb777ad8f090,"" +ef1c5dab-b3a9-444b-b825-8fe3d0248e02,true +ef9360c1-b9b4-4dd9-86de-f996cd22e7a1,"" +efbe6910-0629-46d6-bcfb-5880a1795742,"" +eff17621-813f-4e99-a307-118ac9273efc,"" +f018a615-d5ff-4c3e-84f8-d4ebb1f342bc,"" +f04f4b77-a9f2-4ce1-9d0d-6b43d39483f7,"" +f07f7d83-1fe3-4da4-9c33-86aae3ac67e5,"" +f08704a2-c1f5-44d5-a3f6-43c5608dc987,"" +f0a81ab6-10ea-4859-a064-b3b0dc662f24,"" +f177f59d-ecf0-41a6-b81b-a311eb760976,"" +f1a1aa8c-3779-4c42-8302-6006dcb95151,"" +f1b36b35-1bd3-4328-aea9-4c5b3a7c7404,true +f226c31e-37f4-4a4a-aa1f-aa400447a799,"" +f22fe03d-e1e9-40d5-9ff7-a5bb6e7a2d71,true +f27187d5-f8f0-4188-ae0c-f77ca494a9b3,"" +f27a59e9-c785-47d7-88a4-de7706bb4f92,"" +f28962fb-0214-4664-b9c3-7c67d4eb2e8d,true +f29f4e3c-81f9-49b1-bc52-47a60a3076bb,"" +f2fd6221-529b-42ca-a060-30db0996a398,true +f3047ad3-3524-4a48-a00f-603a65fa0891,"" +f310aaca-1c10-41fc-ac49-8430c4c23656,true +f314d140-929d-4ced-bbd9-c7f0204e99eb,"" +f32094e2-ab74-4567-98c7-e35fe529393a,"" +f3338731-d7b9-4c1f-8e3d-e73b5b756c7b,"" +f3deb81d-79ca-4176-9b6d-bd96bb5b7a16,"" +f3e99f4d-5bbb-4f11-9519-4d3aa15e25cb,true +f3fd705f-3f03-4f26-a477-f36e65fe7499,"" +f4077b1d-84fd-4489-b8b1-bbc9f5b61da2,"" +f475b875-3df0-49fc-b4f9-10b2ac1c40a6,"" +f4bba159-e786-4f15-8100-6bff75c03635,"" +f4e59f5d-12a4-4005-bdae-e157e145c119,"" +f5042323-b136-4c9d-bf57-0b7b70609495,"" +f51f7f2d-968a-4630-8e06-d6beb52b9f6b,true +f55f863e-ffbf-4eb5-8f76-e2069098adcf,"" +f568f305-55f4-4d1f-849f-6c8f371f5051,"" +f5dec406-3636-4ac4-894f-1035ef3ef570,"" +f5e51d8b-bda1-4093-b887-f2355ea171cd,true +f5ebecec-331b-4d57-b353-3f50538cae2a,"" +f5ed5cb8-adc0-424c-8371-ffb8e7cc9bc4,"" +f6514087-db2a-40d8-897a-21b5af7d590e,true +f65d9eb9-e3d4-42fd-8d3b-168a6009f6ed,true +f66efc52-e910-4d73-a9a7-fddc110c16c0,"" +f67e345d-7f27-48bf-afe4-00d79c3cf300,"" +f67f612c-6534-40d1-8e56-c056e886b98d,"" +f6b9b783-c8af-44c2-8443-44b80e972686,true +f6bc9618-f245-4402-b69e-74d424736c4b,true +f703fec9-ca54-4363-9ef0-4c4acdc37e0c,true +f73ca57b-a00f-4217-9106-aedd26812b3d,"" +f74957d5-eef8-4683-976f-c59ffabdeadc,true +f7d2872f-bfc1-496e-ae92-a9d446aa72da,true +f7d6ad2c-1f7e-47ef-adfc-16a5d4d0189a,"" +f8043ec1-8313-45f9-a6dc-4cc1e5ad5f54,true +f8673366-8964-4c6c-aa9f-02e0920f21dc,"" +f8683b38-42d3-4f32-a543-034c05dc07f6,"" +f8816dca-a41e-4ef9-8a17-b40fc7d707ad,"" +f89b5e47-c8c3-4067-99ea-bd22f8932ee1,"" +f8b6ebd6-8d2a-4592-ad16-06772ad32cc7,"" +f8ddb5b8-70ff-4d5b-adf0-1752811f7be2,"" +f8f99d6a-94dc-4fca-8772-d0c3fe887a7f,"" +f912a4cb-2eeb-41f3-a410-0ddc3eab9cdd,"" +f9185eb8-d2e5-47aa-916b-a5ff24612ddf,true +f92f93d5-3037-4692-a062-ee84b9961510,"" +f93aa334-4532-4774-b82c-6d040d3c7156,true +f93e975b-d07d-434d-b227-666e744892c7,"" +f95dafda-7f63-4ddb-acbf-e363dc901b1b,"" +f95f8351-818a-4cb1-b26a-507c4baced47,true +f9aff2d6-fe39-4d17-90cf-917edf5d2bc8,"" +f9f5480b-27da-44fd-84a6-1ee4d4a55e36,"" +fa0ee43e-abc9-44cb-9248-3acc6c40e693,"" +fa4daa52-528e-45f5-8dd6-fe2a2c9fe8ff,true +fa522b1a-3244-4203-966f-546dcfb0c62c,true +fa5e8aa4-84e3-44b7-9dfe-326abdf02162,"" +fa7087f0-0140-4c94-b7c9-185b89c613c8,"" +fa786b6e-dbf4-4c51-a8c6-3006a029e8ba,true +fa80db64-ef07-4b14-aa7d-e93585fd84e2,"" +faa80ca5-9c2a-40f4-aeec-26d982e663ae,"" +faeaaf02-2ae6-4f5b-b729-61fd56d3946c,"" +faf774dd-13ef-4b09-8cc9-3cf33a562482,true +fb176a2c-4b8f-40d7-bb81-f370c96c3f96,true +fb1df190-d719-42b7-8e9c-d7830f92882f,"" +fb42fd3a-123d-4b2b-8a2f-d7e37af0a675,"" +fb55aea6-a5e7-4a55-a8df-967f504023f6,true +fb93624f-3d94-4c5d-9aba-10a3eaea0434,"" +fba16e5e-1b98-484e-8296-43a3995b9f75,"" +fbacdef8-f2e5-4a1c-8a01-b25442a5af89,true +fc348304-8ef3-4b3d-afcc-a66718315d89,"" +fc6dd798-66ac-45e2-a663-ea69b976c120,true +fcdd2cbf-917f-4429-a41b-48f8fe2a188b,"" +fd325c37-4113-45e9-9e55-abd6b2ce6dbf,"" +fd694334-1bcc-40f0-863a-017311fbaecb,"" +fd75e2b2-c780-477c-a813-046ccec6fe51,"" +fd7a8bc2-9005-4230-a4f5-348f4b1f5b16,"" +fd7ef037-c576-498d-bdef-cec86fdd60b0,"" +fdaeb95c-9d66-4da9-87cf-eabbdc593007,"" +fdb161bd-ad0e-47fa-a5bf-f17ece98f28c,"" +fdb49a29-6648-4dc5-bf56-ef948b00d885,"" +fdbbdafe-ed7e-4bd1-ae67-86430153a738,"" +fdc10bfc-2b5b-4a23-a93a-eaa85803bbc3,"" +fdce38d2-ae3a-474f-8024-52279c43b745,"" +fdfcdb50-716b-4452-a4c8-e03d3b8f89a3,"" +fe4c4989-ff06-446e-bf01-5c5d8f69f1eb,"" +fe66bca4-eedf-42a9-8def-d29ef3dd01de,"" +fe719bdd-cc9a-4c93-b2c9-982d051fceb1,true +fe7906dc-a882-488e-b576-2ef3486bcf79,"" +fe7c2db1-c229-4681-9373-e388dccb9e37,"" +fe7cb896-d81d-4b38-885c-4134ea64020e,"" +fe97c34d-b787-4c3a-a972-821eb42a3442,true +fead13f8-4b89-4f33-950b-ee9254a36c4b,true +fead2d6e-2979-4de7-8118-698906954d06,true +ff9df3bf-b8fe-4789-aa34-b205b5143a92,true +ffab80f3-741c-4c67-af21-4585f1c05d2f,"" +ffb89ee2-c3d9-4fd5-b897-a0e0eb692143,"" +fff8bb82-5151-41f9-b150-801ed4957277,true diff --git a/fhir-server/src/test/resources/responses/ParserTest/lengthOfEncounter.csv b/fhir-server/src/test/resources/responses/ParserTest/lengthOfEncounter.csv new file mode 100644 index 0000000000..bbfdbb7687 --- /dev/null +++ b/fhir-server/src/test/resources/responses/ParserTest/lengthOfEncounter.csv @@ -0,0 +1,217 @@ +0134901a-4a69-4b39-92ea-d6f48ec83c6e,true +01ac1476-0c9c-4cd7-82a6-4ff526018e9a,true +0250a217-a663-403b-a708-5d14eadf0c40,true +02b993c0-b358-481c-b0d0-0767387feb9f,true +0364073f-91d8-47a1-b8b0-107c6318a691,true +04945715-8ad5-4d8f-bfda-ae26662a3610,true +04d88eb4-fb1b-4fa1-802a-5624f4c61b32,true +07bb3bb3-09e6-4abf-85f4-8ad113e7afa5,true +0af4a77e-892e-4b3f-9110-4c5224782250,true +0c315d37-c758-4cf5-a7cb-cbf712fa7dfd,false +102e16c5-4920-4dad-b142-0b280b2aacad,false +11dafd5c-85e7-4275-a147-89a63641e35e,true +12b212d8-bc6e-415a-93b0-594381726668,true +12df1bed-5472-4c48-8e88-2cbb3e5eab33,false +151e3048-66ad-4411-8753-677877e3bf0a,false +16a3408d-c927-4d02-a1ae-cad32419caab,false +16d280a2-c61f-487f-9034-22e884158969,false +17bcf2ea-d921-4715-91c5-6b15226b33d3,true +18ebf5ea-b0a2-4333-9e9c-40217de809ff,false +19502b5a-2031-487d-9d9c-2001f959408b,true +1cb88e7a-3db6-4a88-9b68-b0e1492114bc,false +1db1c71b-9eeb-4a98-abc1-eb699b38510c,false +1f3443ee-d15e-4894-b18e-185cfadfcdea,false +1fd714a6-48b4-425a-99b3-ba5c1a995cce,true +202131ae-78bb-4104-89b0-fb90645760f6,true +20fbcb6e-d793-4b05-8e29-8ff82572b0db,true +21995497-0eb8-4c0b-8c23-e6a829f3d596,true +21c6e0fc-bf47-4f80-b1ff-85b940445bdf,true +224e538d-3622-4f5e-b772-211ed358d8de,false +23780032-f3bb-4b40-af2e-3fa6b1677376,true +24c4dd5b-748b-4165-a0cc-2867b76c2dc2,false +2514cdf0-1216-4c5e-bfa8-0c11c20c6b93,false +274a2e49-9170-4945-bca2-ab6ef4bded75,true +2830e99a-e6b0-411b-a051-7ea1e9f815d1,true +29d4e919-2bd2-44e6-bb8a-380a780f60ff,true +2aff9edd-def2-487a-b435-a162e11a303c,false +2bd766e5-60e4-4469-bb97-54f0503a1eb0,false +2bddd98c-86e3-4ae0-9dc6-87da16ab6267,false +2cd8b9e4-2881-45a4-b1a6-c3a38e9d59d5,true +2d2e07ec-e697-4384-a679-867e93740921,false +2de1f829-c9d2-4f22-bf39-536dcb82fc3e,true +2e8eb256-84c9-499a-8bf6-bb39504373e1,true +2ec33cf5-d22d-414b-bf5d-e4b4e9997c0f,true +2ee2ab26-09fb-4e12-bf21-9fed3b4c38de,true +2fc75f11-2097-4e1e-8390-dbff3e844b7a,false +2ffd6142-b75b-406f-bc06-cdb1c02eaefc,false +308eba53-29fa-489a-97dc-741b077841a7,true +30ae4a13-0cc6-4d12-a5dd-fa9288efcc09,false +31d4c712-75b1-4ecb-9d1a-ccc4b8453826,false +3397a796-894d-409c-97de-a9e6f3f88198,true +359cb842-c25b-429f-ba9b-d52f171e5631,true +36160225-76a2-4cf1-8bf8-5a3d3f2ec9d7,true +374fd699-6b74-4500-9d60-2473c7e0364f,false +395019b6-84e8-4919-8b8b-ac64e4a6eade,false +39efc9b8-a75f-43a3-98a2-5bdc1c8207d2,true +3ddf46fe-b5be-456d-810f-ea6a7402236d,true +4148ac36-1dcb-4e96-89cd-355e7e8f919b,false +41d26b1c-57b9-408c-b955-bf0ee1db4809,true +4215b5d0-bdd9-4222-a04a-81bb637d60af,false +42a9a333-d09d-4b9e-af96-1f02af26bac3,true +42aa48c7-68cc-4bee-9730-cff29f0e36c5,false +4506aa76-9d0d-40e4-85bc-5735f74522a0,true +45b25ced-6eed-4fca-8ec1-b7d32ea13efe,false +45ec3b9e-eb82-48b4-b4b6-bd305afdf8b3,true +48cc2275-a478-4ade-b076-cf38e1d16017,true +498f4b18-bd4c-470d-9cde-2fca70ec8964,false +4a464bb5-9373-4f1b-9c03-053c64797114,true +4adcaf72-5241-4877-b61c-f34060576c50,false +4cc605d0-d0c6-4de3-849a-f5f92b35d2a0,false +4cd95073-6db3-4eb2-ac4b-0aacb182b352,false +4cfe72fe-21a0-4201-87b6-ef93695d2495,false +4db144d3-a596-4718-a50a-8ac9175ad386,false +4e6b69c7-61f9-4ff5-8c33-ad400edb9b06,false +4f14ca7f-5332-4263-a7b2-f0a838380309,false +4f342a71-dec3-403e-970b-e4c21b9eb98b,true +4f3d1e93-a28f-446e-91af-2baf0168b82b,true +50eac25a-3761-4de3-8a69-aae52e658300,true +51241857-a7a4-4517-96e3-21f797581f89,true +522e2abe-ad96-4d1a-b5a5-748faa997531,true +54c750aa-570a-4e8e-9a02-418781923e39,true +55f17f44-287f-41aa-a1bc-d1c0104af36e,true +56999896-e36b-4e63-a6b6-dbb85dfe1936,false +578cc35c-0982-4d72-a729-b304c026f075,true +5abe533b-ae5f-47ad-8746-f60caf7483c0,false +5cedf18a-fc44-4c39-a80f-2106a0d76934,true +5e1fe0f2-4517-462b-8287-7824f9a60f4f,true +5f64131b-d410-449a-9de6-35415919fec5,true +62059efc-7607-41c9-a3ba-70948f6a8a1d,true +634f0889-3a83-484a-bcc8-86f48e333c7b,true +67e5cf95-236b-4f75-abc5-034ca2966448,true +67fc12fc-bb9f-40f1-9051-127a788b3081,false +683714ad-5194-49e7-9b8f-4e306cf68ae1,true +6954c5c2-dd77-490a-9152-f1d78eff913d,true +6a5d8a68-bbe0-4408-ada5-a843ee6bd9b0,false +6af73cae-2e4e-485f-a74d-6f4307eb3af3,true +6c84348c-5065-4e89-9412-bfda023683f2,false +6d47a2fe-3645-4c5c-bebe-1b822eff197f,false +6e187f47-91a1-4217-a185-31b6f01db225,true +720f7ed6-7b2e-41dc-a0e0-724a3332aa24,true +721e4027-a080-40d8-bc4a-43cd33477611,true +72788e7f-1bf1-40b5-a1f1-27c669dc7278,true +72c611bb-471e-40f2-a6a8-0ae7b7b6b63e,true +749babeb-6883-4bd4-92a5-bec52769071c,true +75a09d4f-eef2-4404-a386-dfcb408ec9ed,true +777aa5f2-2a09-4aed-92ea-912694e28b48,true +79be3b69-23d8-4408-8f01-68d993e63b6c,true +7ac56d5a-32a7-4b40-a956-356e3006faed,false +7e6fe8ca-a95e-4102-8b18-e6e858cd15a8,false +7e7322a6-7912-4101-b3be-d134245a0626,false +7ea43fc6-b1f7-46be-a308-5ecb275a1081,false +7f410064-638a-4477-85c4-97fc2bb14a49,false +8089a9ac-9e71-4487-a231-f720e4bc8d3e,false +836b2e59-fb97-4014-ab0c-d5a5dc750969,true +85481b3f-c75e-40cd-bacd-b0afb79e893c,true +85c997bf-63d9-4ebb-8e0b-320de3dddc6c,true +85e41a01-04e5-44d2-8b3a-4d3ad7b0f87b,false +86415df5-7e47-4637-9e09-aaad9e7628d1,true +8743e69b-17aa-44ff-b8fa-4f582665efc6,false +87b04a97-1d33-4548-aec9-3d2856070702,false +88b16960-bfff-41d0-81e4-9a4630834a00,true +89f260bb-68b4-4dec-91f4-d52e673e0ff7,false +8a1908f7-47cc-4f82-859c-781a193e9901,false +8bc7af32-e5ad-4849-ba4d-b446db833ab4,true +8be81657-8ba6-4ec5-8ff9-4809367096ea,false +8dc2ce26-aec7-43c0-9771-350af4257ad8,true +8e9e848c-0547-4f2c-8b5f-e33d79bbed67,false +8f76d729-9f74-4cfd-be2a-8b033b568e18,true +900ce9fe-02d3-476b-902a-9467767ecdcf,false +922e2443-9cc5-421f-8310-9cd23f6e9f2d,false +96b2282d-1384-4cfb-9958-f009fb501626,true +97b42d67-8691-433d-8a31-dada076162ae,true +984067fc-3dfc-47b7-8ee0-4d9b27d43860,true +990c21ab-433b-4920-873e-f9dfc7103d9d,false +99fc3558-79f3-4d14-9aa1-ff63f621ecd9,false +9b2eb632-6f1a-4e97-912b-3c8378a1b11c,true +9b4f52b0-51fa-4ea6-b02c-2ed8478066d3,true +9bc516d4-7c82-4340-a90c-bb493f96fbe4,false +9e0b8dc3-65c4-490d-97c0-d5e3db944de5,false +9ed8703e-3b40-424c-9e98-b3b404051f99,false +a1228f20-7c50-4d3a-b88c-2d277ca79d79,false +a221198d-000e-497b-8b70-bb4d37f7bbe1,true +a2c3ee1d-ec35-4b26-9bab-12de3f47d604,false +a6790cbd-8349-432e-a976-5dfc07451203,true +a6b084fb-ada7-480a-9adc-f180d4eb1e2a,false +a6cb423a-7571-46df-83e2-ccc6820adb36,true +a89c0c42-c19f-4d7f-a15e-d04e043c92f6,true +acb2329d-b1c3-45c3-ad28-91a09aa521e1,false +add6d754-a075-4693-a33a-c061c9a368ff,true +ae7ddaef-4911-418c-8401-d978617e145b,true +ae9e663e-8c15-43c9-8a88-52b61cbf07a9,false +b00df815-7528-4967-bfe2-311130d91c21,true +b07fb98d-2da4-423a-83b4-7a673de93096,true +b0d337c5-3555-4817-ba59-4ceea5ad8a91,true +b1ccd55a-6b88-4240-b20c-ca893f36e23b,false +b1d4dc41-07ae-44db-ae17-1df86c5a62cf,true +b5d06aa6-b5c6-4782-a0f8-dbf4121e1baa,false +b6900c21-d310-4fb4-8b8f-176a09c91989,true +b7772635-1801-48e4-a442-f4aaa6860544,true +b870d2cb-ea6a-4b67-8de5-ce1224a18bf2,false +bac374c0-50e8-4a5c-947b-82a8e9a747a9,false +baf48725-f0f9-4357-a71d-b1104910deae,true +bb1a7816-4798-4f58-9ce4-c5bd3af682a8,false +bbd0f936-0cb9-4cc9-858c-2926b2b1c1eb,false +bf895c48-1d52-4780-8e9a-532d69356d28,true +bfc93cb7-e53a-49f7-b86e-81d6a13cfdea,true +c06a9f9b-90fa-4bd6-9581-0c6950f03e4a,true +c3ec1f2e-1411-41e4-8370-acd5a8f68cf4,false +c57d51a7-45de-41b9-92fc-efd0634effaf,false +c5c6eed5-aec6-4b8a-b689-adbb219c2267,false +c892b1d7-7485-407d-8883-54fb7fecebc1,false +c90aae7e-5704-4e13-8794-41ab377193bd,false +ca3e0486-fd6b-4a13-a741-3a47760b412d,false +ca7f269d-3794-4994-8c46-d8e9f2aa6378,false +cc56af6d-25c6-480e-9767-da02a55551da,false +cdb8493c-e3b0-447f-b16b-e58dd64660f3,false +cf67a8d4-48e2-4dc9-a521-6aabcff0330b,true +cfcbe34a-edc5-4442-bc05-5927fa00336b,true +d05461d6-13bf-402c-890d-db6404933f7c,false +d080c116-681a-494a-a928-45924109b49d,false +d535b213-2abc-438f-aa6a-c06476d60b09,false +d6988116-3c63-44f8-9f94-9e9d51cc5a37,true +d79728e1-8834-4f4a-8edc-ce18aca18be6,true +d7a48a26-7731-4046-bf22-78f0b8084eb9,false +d90676d2-ce74-4867-a00f-6dbffa7c00be,true +d9e7dd88-2d7c-4e48-8cf9-9e33f729b7c2,false +db79f75d-af3c-4f82-b4e5-9b5d26598eef,false +def5fd23-2b74-4c64-85e9-fac27e626bb7,true +dfe38e2d-23d5-45c6-86bd-f83fe3b6a1d8,false +e0dfbc08-45ad-4a81-b648-7e65c066f673,true +e1040d58-53bc-4467-8101-ca53b772cede,true +e1c2ad9f-6f61-4f16-805a-2f405b63659a,true +e2387a81-5ff5-4daf-b2e8-881998d0d917,true +e26ae29a-213a-4f79-98c2-cc81cf2f451d,false +e363eb67-64c7-440f-93fd-5c8787c69a85,false +e4358f28-62a8-4e06-b2bd-cb00d3310349,false +e7f68d35-ae55-4fa4-b0be-0672a5a7186a,false +e8c41168-a093-40eb-8baa-6802d24f554a,false +e8eba267-fecb-477e-9625-771fbcfc3cba,true +ede7745a-8f3e-4e20-9f16-33756be7ab6c,false +ee24bf89-81a3-4259-a382-86917f3829d4,false +f1293c5e-c997-4ba9-8bfd-438e7a840dc8,false +f18b08bd-40da-43c1-87ec-4ba23542635f,false +f19eefca-c1ad-4860-bdda-4674a631d464,false +f28931e5-1f35-4f9f-a02e-78398735ea67,false +f29330d0-5b32-4f75-b558-a1c7f05c0b4a,false +f2c9ca81-8b1e-4873-bd8a-1a6e1411193c,true +f3aa491a-4dbd-4436-b674-18b2177dcf18,false +f3c2f842-6aa3-42c9-a0f3-895c40456868,true +f3eb0c38-2571-44e7-be39-732eb52cf1df,true +f6d3ff7b-f6e1-416a-bb05-73dfa8d129b5,true +f77a8561-5adc-452a-ac9a-76273b6a6678,true +f883f2ca-d523-4c9f-86b2-0add137901de,false +fc4d37ec-22b7-4ea0-a34e-dcd4beb2001c,false +fc771883-3bd6-46d9-9626-a130e1b902de,false +fcab9efe-fb05-42d6-b366-ce6db1cc4093,true +fcc916dd-5e4f-4bf7-9aef-c906a36d7301,false +fce20464-ff98-4051-8714-6b9584e52740,true diff --git a/fhir-server/src/test/resources/responses/ParserTest/testQuantityAdditionSubtractionAndEquality.csv b/fhir-server/src/test/resources/responses/ParserTest/testQuantityAdditionSubtractionAndEquality.csv new file mode 100644 index 0000000000..3079631f8e --- /dev/null +++ b/fhir-server/src/test/resources/responses/ParserTest/testQuantityAdditionSubtractionAndEquality.csv @@ -0,0 +1,9 @@ +121503c8-9564-4b48-9086-a22df717948e,true +2b36c1e2-bbe1-45ae-8124-4adad2677702, +7001ad9c-34d2-4eb5-8165-5fdc2147f469, +8ee183e2-b3c0-4151-be94-b945d6aa8c6d,true +9360820c-8602-4335-8b50-c88d627a0c20,true +a7eb2ce7-1075-426c-addd-957b861b0e55,true +bbd33563-70d9-4f6d-a79a-dd1fc55f5ad9, +beff242e-580b-47c0-9844-c1a68c36c5bf, +e62e52ae-2d75-4070-a0ae-3cc78d35ed08,true diff --git a/fhir-server/src/test/resources/responses/ParserTest/testQuantityAdditionWithOverflow_code.csv b/fhir-server/src/test/resources/responses/ParserTest/testQuantityAdditionWithOverflow_code.csv new file mode 100644 index 0000000000..6f23efbb9d --- /dev/null +++ b/fhir-server/src/test/resources/responses/ParserTest/testQuantityAdditionWithOverflow_code.csv @@ -0,0 +1,9 @@ +121503c8-9564-4b48-9086-a22df717948e,m-3 +2b36c1e2-bbe1-45ae-8124-4adad2677702, +7001ad9c-34d2-4eb5-8165-5fdc2147f469, +8ee183e2-b3c0-4151-be94-b945d6aa8c6d,m-3 +9360820c-8602-4335-8b50-c88d627a0c20,m-3 +a7eb2ce7-1075-426c-addd-957b861b0e55,m-3 +bbd33563-70d9-4f6d-a79a-dd1fc55f5ad9, +beff242e-580b-47c0-9844-c1a68c36c5bf, +e62e52ae-2d75-4070-a0ae-3cc78d35ed08,m-3 diff --git a/fhir-server/src/test/resources/responses/ParserTest/testQuantityAdditionWithOverflow_value.csv b/fhir-server/src/test/resources/responses/ParserTest/testQuantityAdditionWithOverflow_value.csv new file mode 100644 index 0000000000..d804ee2487 --- /dev/null +++ b/fhir-server/src/test/resources/responses/ParserTest/testQuantityAdditionWithOverflow_value.csv @@ -0,0 +1,9 @@ +121503c8-9564-4b48-9086-a22df717948e, +2b36c1e2-bbe1-45ae-8124-4adad2677702, +7001ad9c-34d2-4eb5-8165-5fdc2147f469, +8ee183e2-b3c0-4151-be94-b945d6aa8c6d,85389546411730050624531900 +9360820c-8602-4335-8b50-c88d627a0c20,83016978156556952635728000 +a7eb2ce7-1075-426c-addd-957b861b0e55, +bbd33563-70d9-4f6d-a79a-dd1fc55f5ad9, +beff242e-580b-47c0-9844-c1a68c36c5bf, +e62e52ae-2d75-4070-a0ae-3cc78d35ed08,85425566063603919179553900 diff --git a/fhir-server/src/test/resources/responses/ParserTest/testQuantityMultiplicationAndDivision.csv b/fhir-server/src/test/resources/responses/ParserTest/testQuantityMultiplicationAndDivision.csv new file mode 100644 index 0000000000..08b66438c0 --- /dev/null +++ b/fhir-server/src/test/resources/responses/ParserTest/testQuantityMultiplicationAndDivision.csv @@ -0,0 +1,9 @@ +121503c8-9564-4b48-9086-a22df717948e,2.000000 +2b36c1e2-bbe1-45ae-8124-4adad2677702,2.000000 +7001ad9c-34d2-4eb5-8165-5fdc2147f469, +8ee183e2-b3c0-4151-be94-b945d6aa8c6d, +9360820c-8602-4335-8b50-c88d627a0c20, +a7eb2ce7-1075-426c-addd-957b861b0e55, +bbd33563-70d9-4f6d-a79a-dd1fc55f5ad9,2.000000 +beff242e-580b-47c0-9844-c1a68c36c5bf, +e62e52ae-2d75-4070-a0ae-3cc78d35ed08, diff --git a/fhir-server/src/test/resources/responses/ParserTest/testUntilFunction.csv b/fhir-server/src/test/resources/responses/ParserTest/testUntilFunction.csv new file mode 100644 index 0000000000..43e711ecb7 --- /dev/null +++ b/fhir-server/src/test/resources/responses/ParserTest/testUntilFunction.csv @@ -0,0 +1,217 @@ +0134901a-4a69-4b39-92ea-d6f48ec83c6e,19 +01ac1476-0c9c-4cd7-82a6-4ff526018e9a,56 +0250a217-a663-403b-a708-5d14eadf0c40,42 +02b993c0-b358-481c-b0d0-0767387feb9f,0 +0364073f-91d8-47a1-b8b0-107c6318a691,58 +04945715-8ad5-4d8f-bfda-ae26662a3610,28 +04d88eb4-fb1b-4fa1-802a-5624f4c61b32,49 +07bb3bb3-09e6-4abf-85f4-8ad113e7afa5,46 +0af4a77e-892e-4b3f-9110-4c5224782250,51 +0c315d37-c758-4cf5-a7cb-cbf712fa7dfd,50 +102e16c5-4920-4dad-b142-0b280b2aacad,56 +11dafd5c-85e7-4275-a147-89a63641e35e,1 +12b212d8-bc6e-415a-93b0-594381726668,44 +12df1bed-5472-4c48-8e88-2cbb3e5eab33,50 +151e3048-66ad-4411-8753-677877e3bf0a,43 +16a3408d-c927-4d02-a1ae-cad32419caab,56 +16d280a2-c61f-487f-9034-22e884158969,15 +17bcf2ea-d921-4715-91c5-6b15226b33d3,17 +18ebf5ea-b0a2-4333-9e9c-40217de809ff,43 +19502b5a-2031-487d-9d9c-2001f959408b,51 +1cb88e7a-3db6-4a88-9b68-b0e1492114bc,56 +1db1c71b-9eeb-4a98-abc1-eb699b38510c,25 +1f3443ee-d15e-4894-b18e-185cfadfcdea,48 +1fd714a6-48b4-425a-99b3-ba5c1a995cce,58 +202131ae-78bb-4104-89b0-fb90645760f6,0 +20fbcb6e-d793-4b05-8e29-8ff82572b0db,59 +21995497-0eb8-4c0b-8c23-e6a829f3d596,50 +21c6e0fc-bf47-4f80-b1ff-85b940445bdf,49 +224e538d-3622-4f5e-b772-211ed358d8de,48 +23780032-f3bb-4b40-af2e-3fa6b1677376,45 +24c4dd5b-748b-4165-a0cc-2867b76c2dc2,13 +2514cdf0-1216-4c5e-bfa8-0c11c20c6b93,48 +274a2e49-9170-4945-bca2-ab6ef4bded75,26 +2830e99a-e6b0-411b-a051-7ea1e9f815d1,56 +29d4e919-2bd2-44e6-bb8a-380a780f60ff,54 +2aff9edd-def2-487a-b435-a162e11a303c,11 +2bd766e5-60e4-4469-bb97-54f0503a1eb0,43 +2bddd98c-86e3-4ae0-9dc6-87da16ab6267,54 +2cd8b9e4-2881-45a4-b1a6-c3a38e9d59d5,50 +2d2e07ec-e697-4384-a679-867e93740921,40 +2de1f829-c9d2-4f22-bf39-536dcb82fc3e,48 +2e8eb256-84c9-499a-8bf6-bb39504373e1,51 +2ec33cf5-d22d-414b-bf5d-e4b4e9997c0f,50 +2ee2ab26-09fb-4e12-bf21-9fed3b4c38de,51 +2fc75f11-2097-4e1e-8390-dbff3e844b7a,3 +2ffd6142-b75b-406f-bc06-cdb1c02eaefc,44 +308eba53-29fa-489a-97dc-741b077841a7,49 +30ae4a13-0cc6-4d12-a5dd-fa9288efcc09,37 +31d4c712-75b1-4ecb-9d1a-ccc4b8453826,12 +3397a796-894d-409c-97de-a9e6f3f88198,50 +359cb842-c25b-429f-ba9b-d52f171e5631,47 +36160225-76a2-4cf1-8bf8-5a3d3f2ec9d7,49 +374fd699-6b74-4500-9d60-2473c7e0364f,54 +395019b6-84e8-4919-8b8b-ac64e4a6eade,43 +39efc9b8-a75f-43a3-98a2-5bdc1c8207d2,11 +3ddf46fe-b5be-456d-810f-ea6a7402236d,54 +4148ac36-1dcb-4e96-89cd-355e7e8f919b,54 +41d26b1c-57b9-408c-b955-bf0ee1db4809,55 +4215b5d0-bdd9-4222-a04a-81bb637d60af,56 +42a9a333-d09d-4b9e-af96-1f02af26bac3,60 +42aa48c7-68cc-4bee-9730-cff29f0e36c5,43 +4506aa76-9d0d-40e4-85bc-5735f74522a0,53 +45b25ced-6eed-4fca-8ec1-b7d32ea13efe,50 +45ec3b9e-eb82-48b4-b4b6-bd305afdf8b3,12 +48cc2275-a478-4ade-b076-cf38e1d16017,58 +498f4b18-bd4c-470d-9cde-2fca70ec8964,3 +4a464bb5-9373-4f1b-9c03-053c64797114,2 +4adcaf72-5241-4877-b61c-f34060576c50,50 +4cc605d0-d0c6-4de3-849a-f5f92b35d2a0,20 +4cd95073-6db3-4eb2-ac4b-0aacb182b352,53 +4cfe72fe-21a0-4201-87b6-ef93695d2495,1 +4db144d3-a596-4718-a50a-8ac9175ad386,56 +4e6b69c7-61f9-4ff5-8c33-ad400edb9b06,43 +4f14ca7f-5332-4263-a7b2-f0a838380309,46 +4f342a71-dec3-403e-970b-e4c21b9eb98b,55 +4f3d1e93-a28f-446e-91af-2baf0168b82b,45 +50eac25a-3761-4de3-8a69-aae52e658300,60 +51241857-a7a4-4517-96e3-21f797581f89,50 +522e2abe-ad96-4d1a-b5a5-748faa997531,0 +54c750aa-570a-4e8e-9a02-418781923e39,3 +55f17f44-287f-41aa-a1bc-d1c0104af36e,48 +56999896-e36b-4e63-a6b6-dbb85dfe1936,59 +578cc35c-0982-4d72-a729-b304c026f075,48 +5abe533b-ae5f-47ad-8746-f60caf7483c0,40 +5cedf18a-fc44-4c39-a80f-2106a0d76934,53 +5e1fe0f2-4517-462b-8287-7824f9a60f4f,58 +5f64131b-d410-449a-9de6-35415919fec5,46 +62059efc-7607-41c9-a3ba-70948f6a8a1d,54 +634f0889-3a83-484a-bcc8-86f48e333c7b,49 +67e5cf95-236b-4f75-abc5-034ca2966448,22 +67fc12fc-bb9f-40f1-9051-127a788b3081,39 +683714ad-5194-49e7-9b8f-4e306cf68ae1,46 +6954c5c2-dd77-490a-9152-f1d78eff913d,52 +6a5d8a68-bbe0-4408-ada5-a843ee6bd9b0,10 +6af73cae-2e4e-485f-a74d-6f4307eb3af3,52 +6c84348c-5065-4e89-9412-bfda023683f2,42 +6d47a2fe-3645-4c5c-bebe-1b822eff197f,50 +6e187f47-91a1-4217-a185-31b6f01db225,57 +720f7ed6-7b2e-41dc-a0e0-724a3332aa24,50 +721e4027-a080-40d8-bc4a-43cd33477611,26 +72788e7f-1bf1-40b5-a1f1-27c669dc7278,46 +72c611bb-471e-40f2-a6a8-0ae7b7b6b63e,45 +749babeb-6883-4bd4-92a5-bec52769071c,44 +75a09d4f-eef2-4404-a386-dfcb408ec9ed,18 +777aa5f2-2a09-4aed-92ea-912694e28b48,53 +79be3b69-23d8-4408-8f01-68d993e63b6c,34 +7ac56d5a-32a7-4b40-a956-356e3006faed,17 +7e6fe8ca-a95e-4102-8b18-e6e858cd15a8,49 +7e7322a6-7912-4101-b3be-d134245a0626,55 +7ea43fc6-b1f7-46be-a308-5ecb275a1081,40 +7f410064-638a-4477-85c4-97fc2bb14a49,2 +8089a9ac-9e71-4487-a231-f720e4bc8d3e,50 +836b2e59-fb97-4014-ab0c-d5a5dc750969,0 +85481b3f-c75e-40cd-bacd-b0afb79e893c,50 +85c997bf-63d9-4ebb-8e0b-320de3dddc6c,48 +85e41a01-04e5-44d2-8b3a-4d3ad7b0f87b,42 +86415df5-7e47-4637-9e09-aaad9e7628d1,46 +8743e69b-17aa-44ff-b8fa-4f582665efc6,8 +87b04a97-1d33-4548-aec9-3d2856070702,56 +88b16960-bfff-41d0-81e4-9a4630834a00,2 +89f260bb-68b4-4dec-91f4-d52e673e0ff7,43 +8a1908f7-47cc-4f82-859c-781a193e9901,54 +8bc7af32-e5ad-4849-ba4d-b446db833ab4,44 +8be81657-8ba6-4ec5-8ff9-4809367096ea,54 +8dc2ce26-aec7-43c0-9771-350af4257ad8,50 +8e9e848c-0547-4f2c-8b5f-e33d79bbed67,3 +8f76d729-9f74-4cfd-be2a-8b033b568e18,18 +900ce9fe-02d3-476b-902a-9467767ecdcf,46 +922e2443-9cc5-421f-8310-9cd23f6e9f2d,48 +96b2282d-1384-4cfb-9958-f009fb501626,18 +97b42d67-8691-433d-8a31-dada076162ae,46 +984067fc-3dfc-47b7-8ee0-4d9b27d43860,44 +990c21ab-433b-4920-873e-f9dfc7103d9d,49 +99fc3558-79f3-4d14-9aa1-ff63f621ecd9,45 +9b2eb632-6f1a-4e97-912b-3c8378a1b11c,42 +9b4f52b0-51fa-4ea6-b02c-2ed8478066d3,51 +9bc516d4-7c82-4340-a90c-bb493f96fbe4,53 +9e0b8dc3-65c4-490d-97c0-d5e3db944de5,56 +9ed8703e-3b40-424c-9e98-b3b404051f99,52 +a1228f20-7c50-4d3a-b88c-2d277ca79d79,9 +a221198d-000e-497b-8b70-bb4d37f7bbe1,6 +a2c3ee1d-ec35-4b26-9bab-12de3f47d604,40 +a6790cbd-8349-432e-a976-5dfc07451203,44 +a6b084fb-ada7-480a-9adc-f180d4eb1e2a,50 +a6cb423a-7571-46df-83e2-ccc6820adb36,46 +a89c0c42-c19f-4d7f-a15e-d04e043c92f6,0 +acb2329d-b1c3-45c3-ad28-91a09aa521e1,40 +add6d754-a075-4693-a33a-c061c9a368ff,58 +ae7ddaef-4911-418c-8401-d978617e145b,23 +ae9e663e-8c15-43c9-8a88-52b61cbf07a9,56 +b00df815-7528-4967-bfe2-311130d91c21,26 +b07fb98d-2da4-423a-83b4-7a673de93096,48 +b0d337c5-3555-4817-ba59-4ceea5ad8a91,31 +b1ccd55a-6b88-4240-b20c-ca893f36e23b,42 +b1d4dc41-07ae-44db-ae17-1df86c5a62cf,56 +b5d06aa6-b5c6-4782-a0f8-dbf4121e1baa,52 +b6900c21-d310-4fb4-8b8f-176a09c91989,4 +b7772635-1801-48e4-a442-f4aaa6860544,41 +b870d2cb-ea6a-4b67-8de5-ce1224a18bf2,48 +bac374c0-50e8-4a5c-947b-82a8e9a747a9,50 +baf48725-f0f9-4357-a71d-b1104910deae,50 +bb1a7816-4798-4f58-9ce4-c5bd3af682a8,61 +bbd0f936-0cb9-4cc9-858c-2926b2b1c1eb,2 +bf895c48-1d52-4780-8e9a-532d69356d28,18 +bfc93cb7-e53a-49f7-b86e-81d6a13cfdea,46 +c06a9f9b-90fa-4bd6-9581-0c6950f03e4a,44 +c3ec1f2e-1411-41e4-8370-acd5a8f68cf4,54 +c57d51a7-45de-41b9-92fc-efd0634effaf,5 +c5c6eed5-aec6-4b8a-b689-adbb219c2267,4 +c892b1d7-7485-407d-8883-54fb7fecebc1,1 +c90aae7e-5704-4e13-8794-41ab377193bd,58 +ca3e0486-fd6b-4a13-a741-3a47760b412d,5 +ca7f269d-3794-4994-8c46-d8e9f2aa6378,56 +cc56af6d-25c6-480e-9767-da02a55551da,56 +cdb8493c-e3b0-447f-b16b-e58dd64660f3,55 +cf67a8d4-48e2-4dc9-a521-6aabcff0330b,56 +cfcbe34a-edc5-4442-bc05-5927fa00336b,55 +d05461d6-13bf-402c-890d-db6404933f7c,49 +d080c116-681a-494a-a928-45924109b49d,59 +d535b213-2abc-438f-aa6a-c06476d60b09,3 +d6988116-3c63-44f8-9f94-9e9d51cc5a37,52 +d79728e1-8834-4f4a-8edc-ce18aca18be6,60 +d7a48a26-7731-4046-bf22-78f0b8084eb9,43 +d90676d2-ce74-4867-a00f-6dbffa7c00be,56 +d9e7dd88-2d7c-4e48-8cf9-9e33f729b7c2,50 +db79f75d-af3c-4f82-b4e5-9b5d26598eef,42 +def5fd23-2b74-4c64-85e9-fac27e626bb7,18 +dfe38e2d-23d5-45c6-86bd-f83fe3b6a1d8,43 +e0dfbc08-45ad-4a81-b648-7e65c066f673,1 +e1040d58-53bc-4467-8101-ca53b772cede,45 +e1c2ad9f-6f61-4f16-805a-2f405b63659a,57 +e2387a81-5ff5-4daf-b2e8-881998d0d917,57 +e26ae29a-213a-4f79-98c2-cc81cf2f451d,1 +e363eb67-64c7-440f-93fd-5c8787c69a85,49 +e4358f28-62a8-4e06-b2bd-cb00d3310349,16 +e7f68d35-ae55-4fa4-b0be-0672a5a7186a,45 +e8c41168-a093-40eb-8baa-6802d24f554a,59 +e8eba267-fecb-477e-9625-771fbcfc3cba,56 +ede7745a-8f3e-4e20-9f16-33756be7ab6c,0 +ee24bf89-81a3-4259-a382-86917f3829d4,50 +f1293c5e-c997-4ba9-8bfd-438e7a840dc8,17 +f18b08bd-40da-43c1-87ec-4ba23542635f,44 +f19eefca-c1ad-4860-bdda-4674a631d464,28 +f28931e5-1f35-4f9f-a02e-78398735ea67,46 +f29330d0-5b32-4f75-b558-a1c7f05c0b4a,56 +f2c9ca81-8b1e-4873-bd8a-1a6e1411193c,30 +f3aa491a-4dbd-4436-b674-18b2177dcf18,54 +f3c2f842-6aa3-42c9-a0f3-895c40456868,0 +f3eb0c38-2571-44e7-be39-732eb52cf1df,1 +f6d3ff7b-f6e1-416a-bb05-73dfa8d129b5,47 +f77a8561-5adc-452a-ac9a-76273b6a6678,62 +f883f2ca-d523-4c9f-86b2-0add137901de,23 +fc4d37ec-22b7-4ea0-a34e-dcd4beb2001c,43 +fc771883-3bd6-46d9-9626-a130e1b902de,53 +fcab9efe-fb05-42d6-b366-ce6db1cc4093,14 +fcc916dd-5e4f-4bf7-9aef-c906a36d7301,50 +fce20464-ff98-4051-8714-6b9584e52740,7 diff --git a/lib/import/pom.xml b/lib/import/pom.xml index 5dacc5bcec..2c8bec50c4 100644 --- a/lib/import/pom.xml +++ b/lib/import/pom.xml @@ -13,7 +13,7 @@ au.csiro.pathling pathling - 5.4.0 + 6.0.0-SNAPSHOT ../../pom.xml import diff --git a/lib/js/pom.xml b/lib/js/pom.xml index a2ff07adfe..4e9791d5b3 100644 --- a/lib/js/pom.xml +++ b/lib/js/pom.xml @@ -13,7 +13,7 @@ au.csiro.pathling pathling - 5.4.0 + 6.0.0-SNAPSHOT ../../pom.xml js diff --git a/lib/python/pom.xml b/lib/python/pom.xml index 6d6b656dbe..5148fc8619 100644 --- a/lib/python/pom.xml +++ b/lib/python/pom.xml @@ -7,7 +7,7 @@ au.csiro.pathling pathling - 5.4.0 + 6.0.0-SNAPSHOT ../../pom.xml python diff --git a/library-api/pom.xml b/library-api/pom.xml index c5ff1384d9..1cc2049e1a 100644 --- a/library-api/pom.xml +++ b/library-api/pom.xml @@ -8,7 +8,7 @@ pathling au.csiro.pathling - 5.4.0 + 6.0.0-SNAPSHOT library-api jar diff --git a/library-api/src/main/java/au/csiro/pathling/library/PathlingContext.java b/library-api/src/main/java/au/csiro/pathling/library/PathlingContext.java index 9a0ba53885..56db3fb307 100644 --- a/library-api/src/main/java/au/csiro/pathling/library/PathlingContext.java +++ b/library-api/src/main/java/au/csiro/pathling/library/PathlingContext.java @@ -25,7 +25,7 @@ import au.csiro.pathling.encoders.FhirEncoders; import au.csiro.pathling.fhir.DefaultTerminologyServiceFactory; import au.csiro.pathling.fhir.TerminologyServiceFactory; -import au.csiro.pathling.sql.PathlingStrategy; +import au.csiro.pathling.sql.SqlStrategy; import au.csiro.pathling.support.FhirConversionSupport; import au.csiro.pathling.terminology.TerminologyFunctions; import ca.uhn.fhir.context.FhirContext; @@ -77,7 +77,7 @@ private PathlingContext(@Nonnull final SparkSession spark, this.fhirVersion = fhirEncoders.getFhirVersion(); this.fhirEncoders = fhirEncoders; this.terminologyServiceFactory = terminologyServiceFactory; - PathlingStrategy.setup(spark); + SqlStrategy.setup(spark); } /** @@ -105,6 +105,7 @@ public static PathlingContext create(@Nonnull final SparkSession spark, * that all direct or indirect fields of type T in element of type T should be skipped. * @param enableExtensions switches on/off the support for FHIR extensions. * @param enabledOpenTypes list of types that are encoded within open types, such as extensions. + * @param terminologyServerUrl the URL of the terminology server to use * @return then new instance of PathlingContext. */ @Nonnull diff --git a/pom.xml b/pom.xml index 484b881230..995e6b7829 100644 --- a/pom.xml +++ b/pom.xml @@ -19,7 +19,7 @@ au.csiro.pathling pathling - 5.4.0 + 6.0.0-SNAPSHOT pom Pathling @@ -66,7 +66,7 @@ - 5 + 6 UTF-8 6.0.3 @@ -822,6 +822,16 @@ + + + ossrh + https://oss.sonatype.org/content/repositories/snapshots/ + + true + + + + ossrh diff --git a/site/docs/fhirpath/data-types.md b/site/docs/fhirpath/data-types.md index 28ac086bd7..49dae3d6f6 100644 --- a/site/docs/fhirpath/data-types.md +++ b/site/docs/fhirpath/data-types.md @@ -209,9 +209,9 @@ unique to the Pathling implementation. ## Materializable types There is a subset of all possible FHIR types that can be "materialized", i.e. -used as the result of a grouping expression in +used as the result of an aggregation or grouping expression in the [aggregate](/docs/server/operations/aggregate) -operation, or the definition of a column within +operation, or a column expression within the [extract](/docs/server/operations/extract) operation. These types are: diff --git a/site/docs/fhirpath/functions.md b/site/docs/fhirpath/functions.md index 4717c14a40..2b9fa2fb07 100644 --- a/site/docs/fhirpath/functions.md +++ b/site/docs/fhirpath/functions.md @@ -13,93 +13,53 @@ The notation used to describe the type signature of each function is as follows: [input type] -> [function name]([argument name]: [argument type], ...): [return type] ``` -## count - -``` -collection -> count() : Integer -``` - -Returns the [Integer](./data-types#integer) count of the number of items in -the input collection. - -Example: - -``` -Patient.name.given.count() -``` - -See also: [count](https://hl7.org/fhirpath/#count-integer) - -## sum - -``` -collection -> sum() : Integer|Decimal -``` - -Returns the sum of the numeric values ([Integer](./data-types#integer) or -[Decimal](./data-types#decimal)) in the input collection. - -Example: - -``` -Observation.valueDecimal.sum() -``` - -:::note -The `sum` function is not within the FHIRPath specification, and is currently -unique to the Pathling implementation. -::: - -## first +## allFalse ``` -collection -> first() : collection +collection -> allFalse() : Boolean ``` -Returns a collection containing only the first item in the input collection. -This function will return an empty collection if the input collection has no -items. +Takes a collection of Boolean values and returns `true` if all the items are `false`. If any items are `true`, the result is `false`. If the input is empty (`{ }`), the result is `true`. Example: ``` -Patient.name.given.first() +Condition.code.memberOf('http://snomed.info/sct?fhir_vs=refset/32570581000036105').allFalse() ``` -See also: [first](https://hl7.org/fhirpath/#first-collection) +See also: [allFalse](https://hl7.org/fhirpath/#allfalse-boolean) -## empty +## allTrue ``` -collection -> empty() : Boolean +collection -> allTrue() : Boolean ``` -Returns `true` if the input collection is empty, and `false` otherwise. +Takes a collection of Boolean values and returns `true` if all the items are `true`. If any items are `false`, the result is `false`. If the input is empty (`{ }`), the result is `true`. Example: ``` -Patient.reverseResolve(Condition.subject).empty() +Condition.code.memberOf('http://snomed.info/sct?fhir_vs=refset/32570581000036105').allTrue() ``` -See also: [empty](https://hl7.org/fhirpath/#empty-boolean) +See also: [allTrue](https://hl7.org/fhirpath/#alltrue-boolean) -## not +## anyFalse ``` -Boolean -> not() : Boolean +collection -> anyFalse() : Boolean ``` -Returns `true` if the input collection evaluates to `false`, and `false` if it -evaluates to `true`. Otherwise, the result is empty (`{ }`). +Takes a collection of Boolean values and returns `true` if any of the items are `false`. If all the items are `true`, or if the input is empty (`{ }`), the result is `false`. Example: ``` -(Patient.name.given contains 'Frank').not() +Condition.code.memberOf('http://snomed.info/sct?fhir_vs=refset/32570581000036105').anyFalse() ``` -See also: [not](http://hl7.org/fhirpath/#not-boolean) +See also: [anyFalse](https://hl7.org/fhirpath/#anyfalse-boolean) ## anyTrue @@ -117,78 +77,77 @@ Condition.code.memberOf('http://snomed.info/sct?fhir_vs=refset/32570581000036105 See also: [anyTrue](https://hl7.org/fhirpath/#anytrue-boolean) -## anyFalse +## count ``` -collection -> anyFalse() : Boolean +collection -> count() : Integer ``` -Takes a collection of Boolean values and returns `true` if any of the items are `false`. If all the items are `true`, or if the input is empty (`{ }`), the result is `false`. +Returns the [Integer](./data-types#integer) count of the number of items in +the input collection. Example: ``` -Condition.code.memberOf('http://snomed.info/sct?fhir_vs=refset/32570581000036105').anyFalse() +Patient.name.given.count() ``` -See also: [anyFalse](https://hl7.org/fhirpath/#anyfalse-boolean) +See also: [count](https://hl7.org/fhirpath/#count-integer) -## allTrue +## empty ``` -collection -> allTrue() : Boolean +collection -> empty() : Boolean ``` -Takes a collection of Boolean values and returns `true` if all the items are `true`. If any items are `false`, the result is `false`. If the input is empty (`{ }`), the result is `true`. +Returns `true` if the input collection is empty, and `false` otherwise. Example: ``` -Condition.code.memberOf('http://snomed.info/sct?fhir_vs=refset/32570581000036105').allTrue() +Patient.reverseResolve(Condition.subject).empty() ``` -See also: [allTrue](https://hl7.org/fhirpath/#alltrue-boolean) +See also: [empty](https://hl7.org/fhirpath/#empty-boolean) -## allFalse +## extension ``` -collection -> allFalse() : Boolean +[any] -> extension(url: string) : collection ``` -Takes a collection of Boolean values and returns `true` if all the items are `false`. If any items are `true`, the result is `false`. If the input is empty (`{ }`), the result is `true`. - -Example: +Will filter the input collection for items named `extension` with the given url. +This is a syntactical shortcut for `.extension.where(url = string)`, but is +simpler to write. Will return an empty collection if the input collection is +empty or the url is empty. -``` -Condition.code.memberOf('http://snomed.info/sct?fhir_vs=refset/32570581000036105').allFalse() -``` +:::tip +Your extension content will only be encoded upon import if your encoding +configuration has specified that it should be. Data types and maximum depth of +encoding are both configurable. +See [Configuration](/docs/server/configuration#encoding) for more information. +::: -See also: [allFalse](https://hl7.org/fhirpath/#allfalse-boolean) +See +also: [Additional functions](https://hl7.org/fhir/R4/fhirpath.html#functions) -## where +## first ``` -collection -> where(criteria: [any]) : collection +collection -> first() : collection ``` -Returns a collection containing only those elements in the input collection for -which the `criteria` expression evaluates to `true`. Elements for which the -expression evaluates to `false` or an empty collection will return an empty -collection. - -The `$this` keyword can be used within the criteria expression to refer to the -item from the input collection currently under evaluation. The context inside -the arguments is also set to the current item, so paths from the root are -assumed to be path traversals from the current element. +Returns a collection containing only the first item in the input collection. +This function will return an empty collection if the input collection has no +items. Example: ``` -Patient.reverseResolve(Condition.subject).where(recordedDate > @1960).severity +Patient.name.given.first() ``` -See also: -[where](https://hl7.org/fhirpath/#wherecriteria-expression-collection) +See also: [first](https://hl7.org/fhirpath/#first-collection) ## iif @@ -196,8 +155,8 @@ See also: [any] -> iif(condition: Boolean, ifTrue: [any], otherwise: [any]) : [any] ``` -Takes three arguments, the first of which is a Boolean expression. Returns the -second argument if the first argument evaluates to `true`, or the third argument +Takes three arguments, the first of which is a Boolean expression. Returns the +second argument if the first argument evaluates to `true`, or the third argument otherwise. The `ifTrue` and `otherwise` arguments must be of the same type. @@ -235,6 +194,106 @@ a configured See also: [Additional functions](https://hl7.org/fhir/R4/fhirpath.html#functions) +## not + +``` +Boolean -> not() : Boolean +``` + +Returns `true` if the input collection evaluates to `false`, and `false` if it +evaluates to `true`. Otherwise, the result is empty (`{ }`). + +Example: + +``` +(Patient.name.given contains 'Frank').not() +``` + +See also: [not](http://hl7.org/fhirpath/#not-boolean) + +## ofType + +``` +collection -> ofType(type: Resource): collection +``` + +Returns a collection that contains all items in the input collection that are of +the given type. It is often necessary to use the `ofType` function in +conjunction with the `resolve` function, to resolve references that are +polymorphic. + +Example: + +``` +Condition.subject.resolve().ofType(Patient).gender +``` + +:::caution +This function is currently only supported for use with the [resolve](#resolve) +function, for the purpose of disambiguating polymorphic resource references. +::: + +See also: [ofType](https://hl7.org/fhirpath/#oftypetype-identifier-collection) + +## resolve + +``` +Reference -> resolve(): collection +``` + +The `resolve` function is used to traverse references between FHIR resources. +Given a collection of +[References](https://hl7.org/fhir/R4/references.html#Reference), this function +will return a collection of the resources to which they refer. + +Example: + +``` +AllergyIntolerance.patient.resolve().gender +``` + +:::caution +The following types of references are not currently supported: + +- References to individual technical versions of a resource +- Logical references (via identifier) +- References to contained resources +- Absolute literal references +::: + +See also: +[Additional functions](https://hl7.org/fhir/R4/fhirpath.html#functions) + +## reverseResolve + +``` +collection -> reverseResolve(sourceReference: Reference): collection +``` + +In FHIR, resource references are unidirectional, and often the source of the +reference will be a resource type which is not the subject of the current path. + +The `reverseResolve` function takes a collection of Resources as input, and a +[Reference](https://hl7.org/fhir/R4/references.html#Reference) as the argument. +It returns a collection of all the parent resources of the source References +that resolve to the input resource. + +Example: + +``` +Patient.reverseResolve(Encounter.subject).reasonCode +``` + +:::note +The `reverseResolve` function is not within the FHIRPath specification, and is +currently unique to the Pathling implementation. +::: + +:::caution +In regard to types of references supported, the same caveats apply as those +described in the [resolve](#resolve) function. +::: + ## subsumes ``` @@ -271,7 +330,7 @@ collection -> subsumedBy(code: Coding|CodeableConcept) : ``` The `subsumedBy` function is the inverse of the [subsumes](#subsumes) function, -examining whether each input concept is _subsumed by_ any of the argument +examining whether each input concept is _subsumed by_ any of the argument concepts. Example: @@ -290,6 +349,26 @@ requires a configured See also: [Additional functions](https://hl7.org/fhir/R4/fhirpath.html#functions) +## sum + +``` +collection -> sum() : Integer|Decimal +``` + +Returns the sum of the numeric values ([Integer](./data-types#integer) or +[Decimal](./data-types#decimal)) in the input collection. + +Example: + +``` +Observation.valueDecimal.sum() +``` + +:::note +The `sum` function is not within the FHIRPath specification, and is currently +unique to the Pathling implementation. +::: + ## translate ``` @@ -326,106 +405,48 @@ The `translate` function is not within the FHIRPath specification, and is currently unique to the Pathling implementation. ::: -## resolve +## until ``` -Reference -> resolve(): collection +DateTime|Date -> until(end: DateTime|Date, unit: String) : Integer ``` -The `resolve` function is used to traverse references between FHIR resources. -Given a collection of -[References](https://hl7.org/fhir/R4/references.html#Reference), this function -will return a collection of the resources to which they refer. +This function is used to calculate the difference between two `Date` +or `DateTime` values. The result is returned as an integer, with the unit of +time specified by the `unit` argument. Example: ``` -AllergyIntolerance.patient.resolve().gender -``` - -:::caution -The following types of references are not currently supported: - -- References to individual technical versions of a resource -- Logical references (via identifier) -- References to contained resources -- Absolute literal references -::: - -See also: -[Additional functions](https://hl7.org/fhir/R4/fhirpath.html#functions) - -## reverseResolve - -``` -collection -> reverseResolve(sourceReference: Reference): collection -``` - -In FHIR, resource references are unidirectional, and often the source of the -reference will be a resource type which is not the subject of the current path. - -The `reverseResolve` function takes a collection of Resources as input, and a -[Reference](https://hl7.org/fhir/R4/references.html#Reference) as the argument. -It returns a collection of all the parent resources of the source References -that resolve to the input resource. - -Example: - -``` -Patient.reverseResolve(Encounter.subject).reasonCode +period.start.until(%resource.period.end, 'minutes') ``` :::note -The `reverseResolve` function is not within the FHIRPath specification, and is +The `until` function is not within the FHIRPath specification, and is currently unique to the Pathling implementation. ::: -:::caution -The same caveats apply with regards to types of references supported as -described in the [resolve](#resolve) function. -::: - -## ofType - -``` -collection -> ofType(type: Resource): collection -``` - -Returns a collection that contains all items in the input collection that are of -the given type. It is often necessary to use the `ofType` function in -conjunction with the `resolve` function, to resolve references that are -polymorphic. - -Example: +## where ``` -Condition.subject.resolve().ofType(Patient).gender +collection -> where(criteria: [any]) : collection ``` -:::caution -This function is currently only supported for use with the [resolve](#resolve) -function, for the purpose of disambiguating polymorphic resource references. -::: +Returns a collection containing only those elements in the input collection for +which the `criteria` expression evaluates to `true`. Elements for which the +expression evaluates to `false` or an empty collection will return an empty +collection. -See also: [ofType](https://hl7.org/fhirpath/#oftypetype-identifier-collection) +The `$this` keyword can be used within the criteria expression to refer to the +item from the input collection currently under evaluation. The context inside +the arguments is also set to the current item, so paths from the root are +assumed to be path traversals from the current element. -## extension +Example: ``` -[any] -> extension(url: string) : collection +Patient.reverseResolve(Condition.subject).where(recordedDate > @1960).severity ``` -Will filter the input collection for items named `extension` with the given url. -This is a syntactical shortcut for `.extension.where(url = string)`, but is -simpler to write. Will return an empty collection if the input collection is -empty or the url is empty. - -:::tip -Your extension content will only be encoded upon import if your encoding -configuration has specified that it should be. Data types and maximum depth of -encoding are both configurable. -See [Configuration](/docs/server/configuration#encoding) for more information. -::: - -See -also: [Additional functions](https://hl7.org/fhir/R4/fhirpath.html#functions) +See also: +[where](https://hl7.org/fhirpath/#wherecriteria-expression-collection) diff --git a/site/docs/fhirpath/operators.md b/site/docs/fhirpath/operators.md index 64bd781635..364601c95a 100644 --- a/site/docs/fhirpath/operators.md +++ b/site/docs/fhirpath/operators.md @@ -36,13 +36,13 @@ an empty collection. String ordering is strictly lexical and is based on the Unicode value of the individual characters. -All comparison operators return a [Boolean](./data-types#boolean) value. +All comparison operators return a [Boolean](/docs/fhirpath/data-types#boolean) value. * Not all Quantity values are comparable, it depends upon the -comparability of the units. See the -[FHIRPath specification](https://hl7.org/fhirpath/#comparison) for details on -how Quantity values are compared. Quantities with a `comparator` are treated as -not comparable by this implementation. +comparability of the units. See +the FHIRPath specification for +details on how Quantity values are compared. +

See also: [Comparison](https://hl7.org/fhirpath/#comparison) @@ -51,10 +51,10 @@ See also: [Comparison](https://hl7.org/fhirpath/#comparison) The `=` operator returns `true` if the left operand is equal to the right operand, and a `false` otherwise. The `!=` is the inverse of the `=` operator. -Both operands must be singular. The valid types and their combinations is the -same as for the [Comparison operators](#comparison). In addition to this, -[Coding](./data-types#coding) types can be compared using the equality -operators. +Both operands must be singular. The valid types and their combinations is the +same as for the [Comparison operators](#comparison). In addition to this, +[Coding](/docs/fhirpath/data-types#coding) types can +be compared using the equality operators. If one or both of the operands is an empty collection, the operator will return an empty collection. @@ -62,8 +62,7 @@ an empty collection. Not all Quantity, Date and DateTime values can be compared for equality, it depends upon the comparability of the units within the Quantity values. See the [FHIRPath specification](https://hl7.org/fhirpath/#quantity-equality) for -details on how equality works with Quantity values. Quantities with a -`comparator` are treated as not comparable by this implementation. +details on how equality works with Quantity values. See also: [Equality](https://hl7.org/fhirpath/#equality) @@ -77,38 +76,47 @@ The following math operators are supported: - `/` - Division - `mod` - Modulus -Math operators support only [Integer](./data-types#integer) and -[Decimal](./data-types#decimal) operands. - -The type of the two operands can be mixed. `+`, `-` and `*` return the same type -as the left operand, `/` returns [Decimal](./data-types#decimal) and `mod` -returns [Integer](./data-types#integer). +Math operators support [Integer](/docs/fhirpath/data-types#integer), +[Decimal](/docs/fhirpath/data-types#decimal) +and [Quantity](/docs/fhirpath/data-types#quantity) operands. The modulus +operator is not supported for Quantity types. Both operands must be singular. If one or both of the operands is an empty collection, the operator will return an empty collection. -See also: [Math](https://hl7.org/fhirpath/#math) +Integer and Decimal types can be mixed, while Quantity types can only be used +with other Quantity types. + +For Integer and Decimal, `+`, `-` and `*` return the same type as the left +operand, `/` returns [Decimal](/docs/fhirpath/data-types#decimal) and `mod` +returns [Integer](/docs/fhirpath/data-types#integer). + +For Quantity types, math operators return a new Quantity with the canonical unit +common to both operands. If the units are not comparable, an empty collection is +returned. + +See also: [Math](https://hl7.org/fhirpath/#math-2) ## Date/time arithmetic The following operators are supported for date arithmetic: -- `+` - Add a duration to a [Date](./data-types#date) or - [DateTime](./data-types#datetime) -- `-` - Subtract a duration from a [Date](./data-types#date) or - [DateTime](./data-types#datetime) +- `+` - Add a duration to a [Date](/docs/fhirpath/data-types#date) or + [DateTime](/docs/fhirpath/data-types#datetime) +- `-` - Subtract a duration from a [Date](/docs/fhirpath/data-types#date) or + [DateTime](/docs/fhirpath/data-types#datetime) Date arithmetic always has a `DateTime` or `Date` on the left-hand side, and a duration on the right-hand side. The duration operand is a -[calendar duration literal](./data-types#quantity). The use of UCUM units +[calendar duration literal](/docs/fhirpath/data-types#quantity). The use of UCUM units is not supported with these operators. The `Date` or `DateTime` operand must be singular. If it is an empty collection, the operator will return an empty collection. -The use of arithmetic with the [Time](./data-types#time) type is not +The use of arithmetic with the [Time](/docs/fhirpath/data-types#time) type is not supported. See also: [Date/Time Arithmetic](https://hl7.org/fhirpath/#datetime-arithmetic) @@ -123,9 +131,9 @@ The following Boolean operations are supported: - `implies` - Material implication Both operands to a Boolean operator must be singular -[Boolean](./data-types#boolean) values. +[Boolean](/docs/fhirpath/data-types#boolean) values. -All Boolean operators return a [Boolean](./data-types#boolean) value. +All Boolean operators return a [Boolean](/docs/fhirpath/data-types#boolean) value. See also: [Boolean logic](https://hl7.org/fhirpath/#boolean-logic) diff --git a/site/pom.xml b/site/pom.xml index f8549a1cd1..2e4d66665e 100644 --- a/site/pom.xml +++ b/site/pom.xml @@ -13,7 +13,7 @@ au.csiro.pathling pathling - 5.4.0 + 6.0.0-SNAPSHOT ../pom.xml site diff --git a/terminology/pom.xml b/terminology/pom.xml index 86a87381bb..8df39c9a50 100644 --- a/terminology/pom.xml +++ b/terminology/pom.xml @@ -8,7 +8,7 @@ pathling au.csiro.pathling - 5.4.0 + 6.0.0-SNAPSHOT terminology jar @@ -53,7 +53,6 @@ hibernate-validator - org.projectlombok lombok diff --git a/terminology/src/main/scala/au/csiro/pathling/sql/PathlingStrategy.scala b/terminology/src/main/scala/au/csiro/pathling/sql/SqlStrategy.scala similarity index 68% rename from terminology/src/main/scala/au/csiro/pathling/sql/PathlingStrategy.scala rename to terminology/src/main/scala/au/csiro/pathling/sql/SqlStrategy.scala index 74c46cbe66..078ec5aa34 100644 --- a/terminology/src/main/scala/au/csiro/pathling/sql/PathlingStrategy.scala +++ b/terminology/src/main/scala/au/csiro/pathling/sql/SqlStrategy.scala @@ -7,7 +7,7 @@ import org.apache.spark.sql.{SparkSession, Strategy} /** * Custom spark SQL strategy with additional rules for custom Pathling operations. */ -object PathlingStrategy extends Strategy { +object SqlStrategy extends Strategy { override def apply(plan: LogicalPlan): Seq[SparkPlan] = { plan match { @@ -21,13 +21,13 @@ object PathlingStrategy extends Strategy { /** - * Injects PathlingStrategy into a given Spark session. + * Injects SqlStrategy into a given Spark session. * - * @param session Spark session to add PathlingStrategy to + * @param session Spark session to add SqlStrategy to */ def setup(session: SparkSession): Unit = { - if (!session.experimental.extraStrategies.contains(PathlingStrategy)) { - session.experimental.extraStrategies = Seq(PathlingStrategy) ++ session.experimental + if (!session.experimental.extraStrategies.contains(SqlStrategy)) { + session.experimental.extraStrategies = Seq(SqlStrategy) ++ session.experimental .extraStrategies } } diff --git a/terminology/src/test/java/au/csiro/pathling/test/helpers/TerminologyHelpers.java b/terminology/src/test/java/au/csiro/pathling/test/helpers/TerminologyHelpers.java index c14ea05061..620123f8b6 100644 --- a/terminology/src/test/java/au/csiro/pathling/test/helpers/TerminologyHelpers.java +++ b/terminology/src/test/java/au/csiro/pathling/test/helpers/TerminologyHelpers.java @@ -25,7 +25,7 @@ private TerminologyHelpers() { } public static final String SNOMED_URI = "http://snomed.info/sct"; - private static final String SNOMED_VERSION = "http://snomed.info/sct/32506021000036107/version/20210331"; + public static final String SNOMED_VERSION = "http://snomed.info/sct/32506021000036107/version/20210331"; private static final String AST_URI = "http://csiro.au/fhir/au-states-territories"; diff --git a/utilities/pom.xml b/utilities/pom.xml index 8633ca1adf..6a8d438dfe 100644 --- a/utilities/pom.xml +++ b/utilities/pom.xml @@ -8,7 +8,7 @@ pathling au.csiro.pathling - 5.4.0 + 6.0.0-SNAPSHOT utilities jar