From c298fdc975406d7cd2b9f65dfeeaf8cd45ec01f6 Mon Sep 17 00:00:00 2001
From: labkey-matthewb <matthewb@labkey.com>
Date: Fri, 20 Dec 2024 15:23:16 -0800
Subject: [PATCH 01/18] quantity type prototype (just working here, not for
 24.11)

---
 .../org/labkey/api/data/BaseColumnInfo.java   |  15 +-
 .../api/data/ColumnRenderProperties.java      |  32 ++
 .../api/data/ColumnRenderPropertiesImpl.java  |   3 +
 api/src/org/labkey/api/data/DataColumn.java   |  11 +-
 .../org/labkey/api/data/DisplayColumn.java    | 101 +++--
 api/src/org/labkey/api/data/Parameter.java    |   4 +
 api/src/org/labkey/api/data/SQLFragment.java  |  80 +++-
 .../org/labkey/api/data/TableViewForm.java    |  19 +-
 .../api/dataiterator/SimpleTranslator.java    |  61 +--
 .../labkey/api/ontology/KindOfQuantity.java   | 114 +++++
 api/src/org/labkey/api/ontology/Quantity.java | 429 ++++++++++++++++++
 api/src/org/labkey/api/ontology/Unit.java     | 171 +++++++
 .../api/SampleTypeUpdateServiceDI.java        |   7 +-
 query/src/org/labkey/query/sql/QNumber.java   |  40 +-
 query/src/org/labkey/query/sql/QString.java   |   2 +-
 15 files changed, 989 insertions(+), 100 deletions(-)
 create mode 100644 api/src/org/labkey/api/ontology/KindOfQuantity.java
 create mode 100644 api/src/org/labkey/api/ontology/Quantity.java
 create mode 100644 api/src/org/labkey/api/ontology/Unit.java

diff --git a/api/src/org/labkey/api/data/BaseColumnInfo.java b/api/src/org/labkey/api/data/BaseColumnInfo.java
index 81a35776899..abfca991e97 100644
--- a/api/src/org/labkey/api/data/BaseColumnInfo.java
+++ b/api/src/org/labkey/api/data/BaseColumnInfo.java
@@ -1329,12 +1329,19 @@ public void setSortFieldKeysFromXml(String xml)
 
     public static String labelFromName(String name)
     {
-        if (name == null)
-            return null;
-
-        if (name.length() == 0)
+        if (StringUtils.isBlank(name))
             return name;
 
+        //UNDONE This is just for testing the idea (let the DataRegion/DataColumn do this)
+        var index = name.indexOf("__");
+        if (index > 0)
+        {
+            String unit = name.substring(index + 2);
+            if (null != org.labkey.api.ontology.Unit.fromName(unit))
+                name = name.substring(0, index);
+        }
+        //UNDONE
+
         StringBuilder buf = new StringBuilder(name.length() + 10);
         char[] chars = new char[name.length()];
         name.getChars(0, name.length(), chars, 0);
diff --git a/api/src/org/labkey/api/data/ColumnRenderProperties.java b/api/src/org/labkey/api/data/ColumnRenderProperties.java
index 20dde67a2d0..99c8f8dacbc 100644
--- a/api/src/org/labkey/api/data/ColumnRenderProperties.java
+++ b/api/src/org/labkey/api/data/ColumnRenderProperties.java
@@ -20,7 +20,9 @@
 import org.labkey.api.exp.PropertyType;
 import org.labkey.api.gwt.client.DefaultScaleType;
 import org.labkey.api.gwt.client.FacetingBehaviorType;
+import org.labkey.api.ontology.KindOfQuantity;
 import org.labkey.api.ontology.OntologyService;
+import org.labkey.api.ontology.Unit;
 import org.labkey.api.query.FieldKey;
 import org.labkey.api.util.StringExpression;
 
@@ -245,6 +247,36 @@ default String getConceptLabelColumn()
     {
         return null;
     }
+
+    default KindOfQuantity getKindOfQuantity()
+    {
+        var unit = getDisplayUnit();
+        if (null == unit)
+            return null;
+        return unit.getKindOfQuantity();
+    }
+
+    default Unit getDisplayUnit()
+    {
+        if (!getJdbcType().isNumeric())
+            return null;
+        String name = getName();
+        var index = name.lastIndexOf("__");
+        if (index < 0)
+            return null;
+        var unitPart = name.substring(index+2);
+        try
+        {
+            return Unit.valueOf(unitPart);
+        }
+        catch (IllegalArgumentException x)
+        {
+            // pass
+        }
+        return null;
+    }
+
+
     /* End properties loaded by OntologyService */
 
 
diff --git a/api/src/org/labkey/api/data/ColumnRenderPropertiesImpl.java b/api/src/org/labkey/api/data/ColumnRenderPropertiesImpl.java
index a8887f6f4fc..cdc63915ca6 100644
--- a/api/src/org/labkey/api/data/ColumnRenderPropertiesImpl.java
+++ b/api/src/org/labkey/api/data/ColumnRenderPropertiesImpl.java
@@ -25,6 +25,7 @@
 import org.labkey.api.gwt.client.DefaultScaleType;
 import org.labkey.api.gwt.client.DefaultValueType;
 import org.labkey.api.gwt.client.FacetingBehaviorType;
+import org.labkey.api.ontology.Unit;
 import org.labkey.api.query.FieldKey;
 import org.labkey.api.util.StringExpression;
 
@@ -785,6 +786,8 @@ public final Class<?> getJavaClass()
     @Override
     public Class<?> getJavaClass(boolean isNullable)
     {
+        Class<?> ret;
+        boolean isNumeric;
         PropertyType pt = getPropertyType();
         if (pt != null)
             return pt.getJavaType();
diff --git a/api/src/org/labkey/api/data/DataColumn.java b/api/src/org/labkey/api/data/DataColumn.java
index 62287ca4df1..0d0315fa4a1 100644
--- a/api/src/org/labkey/api/data/DataColumn.java
+++ b/api/src/org/labkey/api/data/DataColumn.java
@@ -564,7 +564,7 @@ public HtmlString getFormattedHtml(RenderContext ctx)
         }
         else
         {
-            String formatted = formatValue(ctx, value, getTextExpressionCompiled(ctx), getFormat());
+            String formatted = formatValue(ctx, value, getTextExpressionCompiled(ctx), getFormat(), getDisplayUnit());
 
             if (getRequiresHtmlFiltering())
                 formatted = PageFlowUtil.filter(formatted);
@@ -598,7 +598,7 @@ protected boolean isSelectInputSelected(String entryName, Object value, String v
         if (value instanceof Collection)
         {
             // CONSIDER: stringify values in collection?
-            return ((Collection)value).contains(entryName);
+            return ((Collection<?>)value).contains(entryName);
         }
         return null != entryName && entryName.equals(valueStr);
     }
@@ -915,7 +915,7 @@ protected String h(Object value)
     @Override
     public String getSortHandler(RenderContext ctx, Sort.SortDirection sort)
     {
-        if (_displayColumn == null || _sortFieldKeys == null || _sortFieldKeys.size() == 0)
+        if (_displayColumn == null || _sortFieldKeys == null || _sortFieldKeys.isEmpty())
             return "";
 
         String regionName = ctx.getCurrentRegion().getName();
@@ -940,7 +940,10 @@ public String getTitle(RenderContext ctx)
     {
         if (_caption == null)
             return null;
-        return _caption.eval(ctx);
+        var title = _caption.eval(ctx);
+        if (null != _displayColumn && null != _displayColumn.getDisplayUnit())
+            title += " (" + _displayColumn.getDisplayUnit() + ")";
+        return title;
     }
 
     @Override
diff --git a/api/src/org/labkey/api/data/DisplayColumn.java b/api/src/org/labkey/api/data/DisplayColumn.java
index 8c654821bf0..00dd72f0b9b 100644
--- a/api/src/org/labkey/api/data/DisplayColumn.java
+++ b/api/src/org/labkey/api/data/DisplayColumn.java
@@ -27,6 +27,8 @@
 import org.labkey.api.compliance.PhiTransformedColumnInfo;
 import org.labkey.api.ontology.Concept;
 import org.labkey.api.ontology.OntologyService;
+import org.labkey.api.ontology.Quantity;
+import org.labkey.api.ontology.Unit;
 import org.labkey.api.query.FieldKey;
 import org.labkey.api.stats.ColumnAnalyticsProvider;
 import org.labkey.api.util.DateUtil;
@@ -318,7 +320,7 @@ public ColumnInfo getDisplayColumnInfo()
 
     public abstract Object getValue(RenderContext ctx);
 
-    public abstract Class getValueClass();
+    public abstract Class<?> getValueClass();
 
     public Object getJsonValue(RenderContext ctx)
     {
@@ -397,7 +399,7 @@ private Format createFormat(String formatString, @Nullable DecimalFormatSymbols
     {
         if (null != formatString)
         {
-            Class valueClass = getDisplayValueClass();
+            Class<?> valueClass = getDisplayValueClass();
 
             try
             {
@@ -471,14 +473,14 @@ public StringExpression getTextExpressionCompiled(RenderContext ctx)
     public HtmlString getFormattedHtml(RenderContext ctx)
     {
         Format format = getFormat();
-        return HtmlString.of(formatValue(ctx, getDisplayValue(ctx), getTextExpressionCompiled(ctx), format));
+        Unit unit = getDisplayUnit();
+        return HtmlString.of(formatValue(ctx, getDisplayValue(ctx), getTextExpressionCompiled(ctx), format, unit));
     }
 
     /**
      * Format the display value as text <i>only</i> if there is a text expression or format configured for
      * the display column (which includes any project date and number format settings),
      * otherwise return null.
-     *
      * <b>No html encoding should be performed</b>
      * @see #getFormattedHtml(RenderContext)
      */
@@ -516,7 +518,7 @@ public String getFormattedText(RenderContext ctx)
      * any html encoding.
      */
     @NotNull
-    protected final String formatValue(RenderContext ctx, Object value, StringExpression expr, Format format)
+    protected final String formatValue(RenderContext ctx, final Object value, StringExpression expr, @Nullable Format format, @Nullable Unit displayUnit)
     {
         if (null == value)
             return "";
@@ -525,22 +527,47 @@ protected final String formatValue(RenderContext ctx, Object value, StringExpres
         {
             return expr.eval(ctx);
         }
-        else if (null != format)
+
+        @NotNull String formattedString;
+        if (null != format)
         {
             try
             {
-                return format.format(value);
+                if (null != displayUnit && value instanceof Number number)
+                {
+                    Quantity q = (value instanceof Quantity) ?
+                            (Quantity)value :
+                            displayUnit.getKindOfQuantity().toQuantity(number);
+                    formattedString = q.format(displayUnit, format);
+                }
+                else
+                {
+                    formattedString = format.format(value);
+                }
             }
             catch (IllegalArgumentException e)
             {
                 LOG.warn("Unable to apply format to {} value \"{}\" for column \"{}\", likely a SQL type mismatch between XML metadata and actual ResultSet", value.getClass().getName(), value, getName());
-                return ConvertUtils.convert(value);
+                formattedString = ConvertUtils.convert(value);
             }
         }
         else if (value instanceof String)
-            return (String)value;
+        {
+            formattedString = (String) value;
+        }
+        else
+        {
+            formattedString = ConvertUtils.convert(value);
+        }
+
+        return formattedString;
+    }
+
 
-        return ConvertUtils.convert(value);
+    Unit getDisplayUnit()
+    {
+        ColumnInfo col = getDisplayColumnInfo();
+        return null != col ? col.getDisplayUnit() : null;
     }
 
 
@@ -552,7 +579,8 @@ public String getTsvFormattedValue(RenderContext ctx)
         {
             format = getFormat();
         }
-        return formatValue(ctx, getExportCompatibleValue(ctx), getTextExpressionCompiled(ctx), format);
+        Unit unit = getDisplayUnit();
+        return formatValue(ctx, getExportCompatibleValue(ctx), getTextExpressionCompiled(ctx), format, unit);
     }
 
     public Object getExcelCompatibleValue(RenderContext ctx)
@@ -560,7 +588,7 @@ public Object getExcelCompatibleValue(RenderContext ctx)
         return getExportCompatibleValue(ctx);
     }
 
-    public Object getExportCompatibleValue(RenderContext ctx)
+    public Object  getExportCompatibleValue(RenderContext ctx)
     {
         Object value = getDisplayValue(ctx);
         if (null == value)
@@ -579,7 +607,7 @@ public Object getExportCompatibleValue(RenderContext ctx)
 
     /**
      * Returns the JSON type name for the column's display value,
-     * which might be different than its value (e.g., lookup column)
+     * which might be different from its value (e.g., lookup column)
      * @return JSON type name
      */
     public String getDisplayJsonTypeName()
@@ -596,7 +624,7 @@ public String getJsonTypeName()
         return getJsonTypeName(getValueClass());
     }
 
-    public static String getJsonTypeName(Class valueClass)
+    public static String getJsonTypeName(Class<?> valueClass)
     {
         if (String.class.isAssignableFrom(valueClass))
             return "string";
@@ -618,20 +646,19 @@ else if (Date.class.isAssignableFrom(valueClass))
         return "string";
     }
 
-    public static Class getClassFromJsonTypeName(String typeName)
+    public static Class<?> getClassFromJsonTypeName(String typeName)
     {
         if (typeName == null)
             return String.class;
 
-        switch (typeName)
+        return switch (typeName)
         {
-            case "boolean":  return Boolean.class;
-            case "int":      return Integer.class;
-            case "float":    return Float.class;
-            case "date":     return Date.class;
-            case "string":
-            default:         return String.class;
-        }
+            case "boolean" -> Boolean.class;
+            case "int" -> Integer.class;
+            case "float" -> Float.class;
+            case "date" -> Date.class;
+            default -> String.class;
+        };
     }
 
 
@@ -641,7 +668,7 @@ public Object getDisplayValue(RenderContext ctx)
         return getValue(ctx);
     }
 
-    public Class getDisplayValueClass()
+    public Class<?> getDisplayValueClass()
     {
         return getValueClass();
     }
@@ -770,7 +797,7 @@ public void renderGridHeaderCell(RenderContext ctx, Writer out, String headerCla
         {
             if (!getColumnInfo().getFieldKey().toString().equals(getColumnInfo().getLabel()))
             {
-                boolean suffix = tooltip.length() > 0;
+                boolean suffix = !tooltip.isEmpty();
                 if (suffix)
                 {
                     tooltip.append(" (");
@@ -792,18 +819,18 @@ public void renderGridHeaderCell(RenderContext ctx, Writer out, String headerCla
                     if (null != concept)
                         conceptDisplay = concept.getLabel() + " (" + conceptDisplay + ")";
                 }
-                tooltip.append("\nConcept Annotation: " + conceptDisplay);
+                tooltip.append("\nConcept Annotation: ").append(conceptDisplay);
             }
 
             if (isPhiProtected())
             {
-                if (tooltip.length() > 0)
+                if (!tooltip.isEmpty())
                     tooltip.append("\n");
                 tooltip.append("(PHI protected data removed)");
             }
         }
 
-        if (tooltip.length() > 0)
+        if (!tooltip.isEmpty())
         {
             out.write(" title=\"");
             out.write(PageFlowUtil.filter(tooltip.toString()));
@@ -823,7 +850,7 @@ public void renderGridHeaderCell(RenderContext ctx, Writer out, String headerCla
             style += ";width:" + getWidth() + "px;";
 
         out.write("<div ");
-        if (!"".equals(style))
+        if (!style.isEmpty())
         {
             out.write("style=\"");
             out.write(style);
@@ -844,7 +871,7 @@ public void renderGridHeaderCell(RenderContext ctx, Writer out, String headerCla
             // 31304: click target should fill the entire cell
             out.write("<div class=\"dropdown-toggle\" data-toggle=\"dropdown\"></div>");
             out.write("<ul class=\"dropdown-menu\"");
-            if (tooltip.length() > 0) // 36050
+            if (!tooltip.isEmpty()) // 36050
                 out.write(" title=\"\"");
             out.write(">");
             PopupMenuView.renderTree(navTree, out);
@@ -894,11 +921,7 @@ private boolean isFiltered(RenderContext ctx)
                 ActionURL url = ctx.getSortFilterURLHelper();
                 SimpleFilter filter = new SimpleFilter(url, rgn.getName());
 
-                filteredColSet = new HashSet<>();
-                for (FieldKey fieldKey : filter.getWhereParamFieldKeys())
-                {
-                    filteredColSet.add(fieldKey);
-                }
+                filteredColSet = new HashSet<>(filter.getWhereParamFieldKeys());
                 ctx.put(rgn.getName() + ".filteredCols", filteredColSet);
             }
 
@@ -1115,13 +1138,15 @@ protected String getHoverTitle(RenderContext ctx)
         return null;
     }
 
-    @NotNull /** Always return a non-null string to make it easy to concatenate values */
+    /** Always return a non-null string to make it easy to concatenate values */
+    @NotNull
     public String getDisplayClass(RenderContext ctx)
     {
         return _displayClass != null ? _displayClass : "";
     }
 
-    @NotNull /** Always return a non-null string to make it easy to concatenate values */
+    /** Always return a non-null string to make it easy to concatenate values */
+    @NotNull
     public String getCssStyle(RenderContext ctx)
     {
         String style = "";
@@ -1283,7 +1308,7 @@ public void renderHiddenFormInput(RenderContext ctx, Writer out) throws IOExcept
 
     protected void renderHiddenFormInput(RenderContext ctx, Writer out, String formFieldName, Object value) throws IOException
     {
-        out.write(new Input.InputBuilder()
+        out.write(new Input.InputBuilder<>()
             .name(getInputPrefix() + formFieldName)
             .type("hidden")
             .value(null != value ? value.toString() : null)
diff --git a/api/src/org/labkey/api/data/Parameter.java b/api/src/org/labkey/api/data/Parameter.java
index 1655ee18f7d..7f4dfe40c0e 100644
--- a/api/src/org/labkey/api/data/Parameter.java
+++ b/api/src/org/labkey/api/data/Parameter.java
@@ -23,6 +23,7 @@
 import org.json.JSONObject;
 import org.labkey.api.attachments.AttachmentFile;
 import org.labkey.api.exp.Lsid;
+import org.labkey.api.ontology.Quantity;
 import org.labkey.api.query.QueryService;
 import org.labkey.api.util.ResultSetUtil;
 import org.labkey.api.util.UnexpectedException;
@@ -378,6 +379,9 @@ public static Object getValueToBind(@Nullable Object value, @Nullable JdbcType t
         if (value == null)
             return null;
 
+        if (value instanceof Quantity q)
+            value = q.value();
+
         if (value instanceof Double)
             return ResultSetUtil.mapJavaDoubleToDatabaseDouble(((Double)value));
         if (value instanceof Number || value instanceof String)
diff --git a/api/src/org/labkey/api/data/SQLFragment.java b/api/src/org/labkey/api/data/SQLFragment.java
index 353975802eb..2d7ff022b58 100644
--- a/api/src/org/labkey/api/data/SQLFragment.java
+++ b/api/src/org/labkey/api/data/SQLFragment.java
@@ -22,6 +22,7 @@
 import org.junit.Assert;
 import org.junit.Test;
 import org.labkey.api.data.dialect.SqlDialect;
+import org.labkey.api.ontology.Quantity;
 import org.labkey.api.query.AliasManager;
 import org.labkey.api.query.FieldKey;
 import org.labkey.api.settings.AppProps;
@@ -29,6 +30,8 @@
 import org.labkey.api.util.JdbcUtil;
 import org.labkey.api.util.Pair;
 
+import java.math.BigDecimal;
+import java.math.BigInteger;
 import java.sql.Timestamp;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -471,10 +474,17 @@ public SQLFragment appendValue(Integer I)
     {
         if (null == I)
             return appendNull();
-        getStringBuilder().append((int)I);
+        getStringBuilder().append(I.intValue());
         return this;
     }
 
+    public SQLFragment appendValue(int i)
+    {
+        getStringBuilder().append(i);
+        return this;
+    }
+
+
     public SQLFragment appendValue(Long L)
     {
         if (null == L)
@@ -483,11 +493,52 @@ public SQLFragment appendValue(Long L)
         return this;
     }
 
+    public SQLFragment appendValue(long l)
+    {
+        getStringBuilder().append(l);
+        return this;
+    }
+
     public SQLFragment appendValue(Float F)
     {
         if (null == F)
             return appendNull();
-        getStringBuilder().append((float)F);
+        return appendValue(F.floatValue());
+    }
+
+    public SQLFragment appendValue(float f)
+    {
+        if (Float.isFinite(f))
+        {
+            getStringBuilder().append(f);
+        }
+        else
+        {
+            getStringBuilder().append("?");
+            add(f);
+        }
+        return this;
+    }
+
+    public SQLFragment appendValue(Double D)
+    {
+        if (null == D)
+            return appendNull();
+        else
+            return appendValue(D.doubleValue());
+    }
+
+    public SQLFragment appendValue(double d)
+    {
+        if (Double.isFinite(d))
+        {
+            getStringBuilder().append(d);
+        }
+        else
+        {
+            getStringBuilder().append("?");
+            add(d);
+        }
         return this;
     }
 
@@ -495,8 +546,24 @@ public SQLFragment appendValue(Number N)
     {
         if (null == N)
             return appendNull();
-        // Do we know that default java toString() for all numbers creates a valid SQL literal?
-        getStringBuilder().append(String.valueOf(N));
+
+        if (N instanceof Quantity q)
+            N = q.value();
+
+        if (N instanceof BigDecimal || N instanceof BigInteger || N instanceof Long)
+        {
+            getStringBuilder().append(String.valueOf(N));
+        }
+        else if (Double.isFinite(N.doubleValue()))
+        {
+            // Do we know that default java toString() for all numbers creates a valid SQL literal?
+            getStringBuilder().append(String.valueOf(N));
+        }
+        else
+        {
+            getStringBuilder().append(" ? ");
+            add(N);
+        }
         return this;
     }
 
@@ -1217,10 +1284,9 @@ public static SQLFragment join(Iterable<SQLFragment> fragments, String separator
 
 
     /* REMOVE THIS - These methods are going away, but this allows us to merge w/o doing 100 modules at the same time */
-    @Deprecated public SQLFragment append(@NotNull Container c) {return appendValue(c);}
+//    @Deprecated public SQLFragment append(@NotNull Container c) {return appendValue(c);}
     @Deprecated public SQLFragment append(Integer i) {return appendValue(i);}
-    @Deprecated public SQLFragment append(java.util.Date date) {return appendValue(date);}
-//    @Deprecated public SQLFragment append(Object o) {return append(String.valueOf(o));}
+//    @Deprecated public SQLFragment append(java.util.Date date) {return appendValue(date);}
     @Deprecated public SQLFragment appendStringLiteral(CharSequence s) {return appendValue(s);}
     /* END OF REMOVE THIS */
 }
diff --git a/api/src/org/labkey/api/data/TableViewForm.java b/api/src/org/labkey/api/data/TableViewForm.java
index 3d208878168..1ed90ded2e6 100644
--- a/api/src/org/labkey/api/data/TableViewForm.java
+++ b/api/src/org/labkey/api/data/TableViewForm.java
@@ -34,6 +34,8 @@
 import org.labkey.api.action.ReturnUrlForm;
 import org.labkey.api.action.SpringActionController;
 import org.labkey.api.collections.CaseInsensitiveHashMap;
+import org.labkey.api.ontology.Quantity;
+import org.labkey.api.ontology.Unit;
 import org.labkey.api.query.SchemaKey;
 import org.labkey.api.security.permissions.DeletePermission;
 import org.labkey.api.security.permissions.InsertPermission;
@@ -420,21 +422,23 @@ protected void _populateValues(BindException errors)
             {
                 if (null != str)
                 {
-                    propType = _dynaClass.getTruePropType(propName);
-                    if (propType != null)
+                    Object val;
+                    if (null != defaultUnit)
                     {
-                        Object val = ConvertUtils.convert(str, propType);
-                        values.put(propName, val);
+                        val = Quantity.convert(str, defaultUnit);
                     }
                     else
                     {
-                        values.put(propName, str);
+                        propType = _dynaClass.getTruePropType(propName);
+                        if (propType != null)
+                            val = ConvertUtils.convert(str, propType);
+                        else
+                            val = str;
                     }
+                    values.put(propName, val);
                 }
                 else if (_validateRequired && null != _tinfo)
                 {
-                    ColumnInfo col = getColumnByFormFieldName(propName);
-
                     if (null == col || !col.isRequired())
                     {
                         values.put(propName, null);
@@ -471,7 +475,6 @@ else if (_validateRequired && null != _tinfo)
                 boolean skipError = false;
 
                 // Attempt to resolve lookups by display value
-                ColumnInfo col = getColumnByFormFieldName(propName);
                 if (col != null && col.getFk() != null && col.getFk().allowImportByAlternateKey())
                 {
                     ForeignKey fk = col.getFk();
diff --git a/api/src/org/labkey/api/dataiterator/SimpleTranslator.java b/api/src/org/labkey/api/dataiterator/SimpleTranslator.java
index a655e6de9ca..29e0f0a45b6 100644
--- a/api/src/org/labkey/api/dataiterator/SimpleTranslator.java
+++ b/api/src/org/labkey/api/dataiterator/SimpleTranslator.java
@@ -55,6 +55,7 @@
 import org.labkey.api.exp.PropertyType;
 import org.labkey.api.files.FileContentService;
 import org.labkey.api.gwt.client.model.PropertyValidatorType;
+import org.labkey.api.ontology.Unit;
 import org.labkey.api.query.AbstractQueryUpdateService;
 import org.labkey.api.query.BatchValidationException;
 import org.labkey.api.query.FieldKey;
@@ -480,7 +481,7 @@ protected class DerivationScopedConvertColumn extends SimpleConvertColumn
 
         public DerivationScopedConvertColumn(int index, SimpleConvertColumn convertCol, int derivationDataColInd, boolean isDerivation, @Nullable String presentDerivationWarning, @Nullable String presentNonDerivationWarning)
         {
-            super(convertCol.fieldName, convertCol.index, convertCol.type);
+            super(convertCol.fieldName, convertCol.index, convertCol.type, convertCol.defaultUnit);
             _convertCol = convertCol;
             this.index = index;
             this.derivationDataColInd = derivationDataColInd;
@@ -558,12 +559,12 @@ protected class AliasColumn extends SimpleConvertColumn
     {
         AliasColumn(String fieldName, int index)
         {
-            super(fieldName, index, null);
+            super(fieldName, index, null, null);
         }
 
         AliasColumn(String fieldName, int index, JdbcType convert)
         {
-            super(fieldName, index, convert);
+            super(fieldName, index, convert, null);
         }
 
         @Override
@@ -610,23 +611,22 @@ protected class SimpleConvertColumn implements Supplier<Object>
     {
         final int index;
         final @Nullable JdbcType type;
+        final @Nullable Unit defaultUnit;
         final String fieldName;
         final boolean _preserveEmptyString;
 
-        SimpleConvertColumn(String fieldName, int indexFrom, @Nullable JdbcType to)
+        SimpleConvertColumn(String fieldName, int indexFrom, @Nullable JdbcType to, @Nullable Unit defaultUnit)
         {
-            this.fieldName = fieldName;
-            this.index = indexFrom;
-            this.type = to;
-            _preserveEmptyString = false;
+            this(fieldName, indexFrom, to, defaultUnit, false);
         }
 
-        public SimpleConvertColumn(String fieldName, int indexFrom, @Nullable JdbcType to, boolean preserveEmptyString)
+        public SimpleConvertColumn(String fieldName, int indexFrom, @Nullable JdbcType to, @Nullable Unit defaultUnit, boolean preserveEmptyString)
         {
             this.index = indexFrom;
             this.type = to;
             this.fieldName = fieldName;
-            _preserveEmptyString = preserveEmptyString;
+            this.defaultUnit = (null==type || type.isNumeric()) ? defaultUnit : null;
+            _preserveEmptyString = preserveEmptyString && null != type && type.isText();
         }
 
         @Override
@@ -646,11 +646,20 @@ final public Object get()
             }
         }
 
-        protected Object convert(Object o)
+        protected Object simpleConvert(Object o)
         {
-            if (o instanceof String && JdbcType.VARCHAR.equals(type) && "".equals(o) && _preserveEmptyString)
+            if (_preserveEmptyString && "".equals(o))
                 return "";
-            return null==type ? o : type.convert(o);
+            if (null != defaultUnit)
+                return defaultUnit.convert(o);
+            if (null != type)
+                return type.convert(o);
+            return o;
+        }
+
+        protected Object convert(Object o)
+        {
+            return simpleConvert(o);
         }
 
         protected Object getSourceValue()
@@ -774,15 +783,10 @@ private class MissingValueConvertColumn extends SimpleConvertColumn
         boolean supportsMissingValue = true;
         int indicator;
 
-        MissingValueConvertColumn(String fieldName, int index,JdbcType to)
-        {
-            super(fieldName, index, to);
-            indicator = NO_MV_INDEX;
-        }
 
-        MissingValueConvertColumn(String fieldName, int index, int indexIndicator, @Nullable JdbcType to)
+        MissingValueConvertColumn(String fieldName, int index, int indexIndicator, @Nullable JdbcType to, @Nullable Unit defaultUnit)
         {
-            super(fieldName, index, to);
+            super(fieldName, index, to, defaultUnit);
             indicator = indexIndicator;
         }
 
@@ -831,9 +835,7 @@ public Object convert(Object value)
 
         Object innerConvert(Object value)
         {
-            if (type != null)
-                return type.convert(value);
-            return value;
+            return super.simpleConvert(value);
         }
     }
 
@@ -842,10 +844,9 @@ private class PropertyConvertColumn extends MissingValueConvertColumn
     {
         @Nullable PropertyType pt;
 
-        PropertyConvertColumn(String fieldName, int fromIndex, int mvIndex, boolean supportsMissingValue, @Nullable PropertyType pt, @Nullable JdbcType type)
+        PropertyConvertColumn(String fieldName, int fromIndex, int mvIndex, boolean supportsMissingValue, @Nullable PropertyType pt, @Nullable JdbcType type, Unit defaultUnit)
         {
-            super(fieldName, fromIndex, mvIndex, type != null ? type : pt != null ? pt.getJdbcType() : null);
-            this.pt = pt;
+            super(fieldName, fromIndex, mvIndex, type != null ? type : pt != null ? pt.getJdbcType() : null, defaultUnit);
             this.supportsMissingValue = supportsMissingValue;
         }
 
@@ -862,9 +863,9 @@ private class PropertyConvertAndTrimColumn extends PropertyConvertColumn
     {
         boolean trimRightOnly;
 
-        PropertyConvertAndTrimColumn(String fieldName, int fromIndex, int mvIndex, boolean supportsMissingValue, @Nullable PropertyType pt, @Nullable JdbcType type, boolean trimRightOnly)
+        PropertyConvertAndTrimColumn(String fieldName, int fromIndex, int mvIndex, boolean supportsMissingValue, @Nullable PropertyType pt, @Nullable JdbcType type, @Nullable Unit defaultUnit, boolean trimRightOnly)
         {
-            super(fieldName, fromIndex, mvIndex, supportsMissingValue, pt, type);
+            super(fieldName, fromIndex, mvIndex, supportsMissingValue, pt, type, defaultUnit);
             this.trimRightOnly = trimRightOnly;
         }
 
@@ -890,7 +891,7 @@ private class MultiValueConvertColumn extends SimpleConvertColumn
 
         MultiValueConvertColumn(SimpleConvertColumn c)
         {
-            super(c.fieldName, c.index, c.type);
+            super(c.fieldName, c.index, c.type, c.defaultUnit);
             _c = c;
         }
 
@@ -946,7 +947,7 @@ protected class RemapPostConvertColumn extends SimpleConvertColumn
 
         public RemapPostConvertColumn(final @NotNull SimpleConvertColumn convertCol, final int fromIndex, final @NotNull ColumnInfo toCol, RemapMissingBehavior missing, boolean includeTitleColumn)
         {
-            super(convertCol.fieldName, convertCol.index, convertCol.type);
+            super(convertCol.fieldName, convertCol.index, convertCol.type, convertCol.defaultUnit);
             _convertCol = convertCol;
             _toCol = toCol;
             _missing = missing;
diff --git a/api/src/org/labkey/api/ontology/KindOfQuantity.java b/api/src/org/labkey/api/ontology/KindOfQuantity.java
new file mode 100644
index 00000000000..f91979f56af
--- /dev/null
+++ b/api/src/org/labkey/api/ontology/KindOfQuantity.java
@@ -0,0 +1,114 @@
+package org.labkey.api.ontology;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+
+
+/**
+ * These helpers follow <a href="https://ucum.org/ucum">UCUM</a> conventions (or at least intend to).
+ * <br>
+ * NOTE: We have an initialization ordering issue as Unit and KindOfQuantity are both enums and they point to each other.
+ * Just in case you were wondering why I don't use Unit directly in the constructor.
+ */
+
+public enum KindOfQuantity
+{
+    Volume("volume", "ml")
+    {
+        @Override
+        List<Unit> getCommonUnits()
+        {
+            return List.of(Unit.l, Unit.ml, Unit.ul);
+        }
+    },
+
+    Mass("mass", "g")
+    {
+        @Override
+        List<Unit> getCommonUnits()
+        {
+            return List.of(Unit.kg, Unit.g, Unit.mg ,Unit.ug);
+        }
+    },
+
+    // Not a real unit per UCUM, but useful for annotation of "storage amount" for instance.
+    Count("", "no_unit")
+    {
+        @Override
+        List<Unit> getCommonUnits()
+        {
+            return List.of(Unit.no_unit);
+        }
+    };
+
+    final @NotNull String name;
+    final @NotNull String storageUnitName;
+    Unit storageUnit = null;
+
+    KindOfQuantity(@NotNull String name, @NotNull String storageUnitName) // , List<Unit> list)
+    {
+        this.name = name;
+        this.storageUnitName = storageUnitName;
+    }
+
+    @NotNull String getName()
+    {
+        return name;
+    }
+
+    /* default unit for data entry */
+    @NotNull Unit getDefaultDisplayUnit()
+    {
+        return storageUnit;
+    }
+
+    /* unit used for database storage and in-memory representation of Quantity*/
+    Unit getStorageUnit()
+    {
+        if (null == storageUnit)
+            storageUnit = Unit.fromName(storageUnitName);
+        return storageUnit;
+    }
+
+    public Quantity toQuantity(Number n)
+    {
+        return Quantity.of(n, getStorageUnit());
+    }
+
+    @SuppressWarnings("BooleanMethodIsAlwaysInverted")
+    boolean accept(Unit unit)
+    {
+        return getStorageUnit().base == unit.base;
+    }
+
+    abstract List<Unit> getCommonUnits();
+
+    static KindOfQuantity getKindOfQuantity(String name)
+    {
+        if ("volume".equalsIgnoreCase(name))
+            return Volume;
+        if ("vol".equalsIgnoreCase(name))
+            return Volume;
+        if ("mass".equalsIgnoreCase(name))
+            return Mass;
+        if ("weight".equalsIgnoreCase(name))
+            return Mass;
+        if ("count".equalsIgnoreCase(name))
+            return Count;
+        return null;
+    }
+
+    // other potentially useful KindOfQuantity
+    //
+    // Fixed Unit e.g. arbitrary UCUM unit w/no conversion supported (basically a column annotation)
+    // if we support Fixed Unit, then maybe KindOfQuantity is used sparingly
+    //
+    // * time (aka duration, not datetime): 60s
+    // * length:        1m
+    // * area           1m2
+    // * temperature/change in temperature has pitfalls
+    // * mass concentration
+    // * per volume (e.g. count per volume) /ml
+}
+
diff --git a/api/src/org/labkey/api/ontology/Quantity.java b/api/src/org/labkey/api/ontology/Quantity.java
new file mode 100644
index 00000000000..e397cb1cd26
--- /dev/null
+++ b/api/src/org/labkey/api/ontology/Quantity.java
@@ -0,0 +1,429 @@
+package org.labkey.api.ontology;
+
+import org.apache.commons.beanutils.ConversionException;
+import org.apache.commons.beanutils.ConvertUtils;
+import org.apache.commons.beanutils.Converter;
+import org.apache.commons.lang3.StringUtils;
+import org.jetbrains.annotations.NotNull;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.math.BigDecimal;
+import java.text.Format;
+import java.util.regex.Pattern;
+
+import static org.labkey.api.ontology.Unit.g;
+
+/* CONSIDER: it's tempting to store BigDecimal in memory after parse for math/conversion purposed, even if we store as double in the database */
+
+/*
+ *  There is a design decision here
+ *      "value" is always relative to the Kind.getDefaultUnit()
+ * or
+ *      "value" is relative to a stored/associated unit
+ *
+ * I think there is less room for error if Quantity is always the stored/database value, but
+ * this means that formatting code needs to be careful.
+ *
+ * There is also value in mimic-ing LabKey SQL semantics.  I think there is value in NOT
+ * translating the "number". E.g. always have "Volume" typed data in the same scale, and always having Mass
+ * typed data in the same scale.  Then units become a parse/display thing.
+ *
+ * LabKey SQL ideas
+ *
+ * CAST takes a bare number and creates a quantity type.  Warns when converting a Quantity to another kind of Quantity
+ *
+ * 1.23                         // untyped
+ * SET CAST(1.23 AS Mass)       // 1.23g -- Convert to a Mass quantity with default unit g, display unit is 'g'
+ * CAST(1.23 AS Mass('g'));     // 1.23g -- same as above, but 'g' is explicit
+ * CAST(1.23 AS Mass('kg'));    // 1230g -- value is converted to g, display unit is 'kg'
+ *
+ * Since value is always stored in the same unit, there are no converting arithmetic methods/operators.
+ * LabKey SQL does not unit arithmetic. It will preserve the kind of quantity for simple calculations
+ *
+ * SUM(Mass) -> Mass
+ * Mass plus/minus Mass -> Mass
+ * Mass times/divide number -> Mass
+ * Mass/Volume = Double
+ *
+ * If you want to display a column in kg, don't do this "SELECT weight/1000".  That will create a new small Mass quantity
+ * e.g. 7123g/1000 -> 7.123g.
+ *
+ *  SELECT weight as weight_in_kg @unit=kg,
+ * or
+ *  SELECT (CAST weight as DOUBLE)/1000.0 as weight_in_kg
+ *
+ */
+public class Quantity extends Number implements Comparable<Quantity>
+{
+    public final @NotNull KindOfQuantity kind;
+    public final Number value;
+    private final boolean isDouble;
+
+    private Quantity()
+    {
+        throw new IllegalStateException();
+    }
+
+    /* Returns a quantity = value*units
+     *    of(1, Kg) -> 1000g
+     */
+    public static Quantity of(Number value, Unit unit)
+    {
+        if (value instanceof Quantity q)
+        {
+            if (unit.kindOfQuantity != q.kind)
+                throw new ConversionException("Cannot convert " + q.format() + " to " + unit);
+            return q;
+        }
+        if (value instanceof BigDecimal bd)
+            return new Quantity(unit.kindOfQuantity, bd, unit);
+        if (value instanceof Long l && (l > Integer.MAX_VALUE || l < Integer.MIN_VALUE))
+            return new Quantity(unit.kindOfQuantity, BigDecimal.valueOf(l), unit);
+        return new Quantity(unit.kindOfQuantity, value.doubleValue(), unit);
+    }
+
+    protected Quantity(@NotNull KindOfQuantity kind, BigDecimal value)
+    {
+        this.kind = kind;
+        this.value = value;
+        this.isDouble = false;
+    }
+
+    protected Quantity(@NotNull KindOfQuantity kind, BigDecimal value, Unit from)
+    {
+        this.kind = kind;
+        this.value = from.toStorageUnitValue(value);
+        this.isDouble = this.value instanceof Double;
+        assert isDouble || this.value instanceof BigDecimal;
+    }
+
+    protected Quantity(@NotNull KindOfQuantity kind, Double value)
+    {
+        this.kind = kind;
+        this.value = value;
+        this.isDouble = true;
+    }
+
+    protected Quantity(@NotNull KindOfQuantity kind, Double value, Unit from)
+    {
+        this.kind = kind;
+        this.value = from.toStorageUnitValue(value);
+        this.isDouble = this.value instanceof Double;
+        assert isDouble || this.value instanceof BigDecimal;
+    }
+
+    public String format()
+    {
+        return format(kind.getDefaultDisplayUnit());
+    }
+
+    public String format(Unit unit)
+    {
+        return unit.fromStorageUnitValue(value) + unit.print;
+    }
+
+    public String format(Format format)
+    {
+        return format(kind.getDefaultDisplayUnit(), format);
+    }
+
+    public String format(Unit unit, Format format)
+    {
+        return format.format(unit.fromStorageUnitValue(value)) + unit.print;
+    }
+
+    @Override
+    public String toString()
+    {
+        return kind.getName() + ":" + format(kind.getStorageUnit());
+    }
+
+    @Override
+    public boolean equals(Object obj)
+    {
+        return obj instanceof Quantity other && 0 == compareTo(other);
+    }
+
+    @Override
+    public int compareTo(@NotNull Quantity other)
+    {
+        if (this.kind != other.kind)
+            throw new IllegalArgumentException("Can't compare " + this.kind + " and " + other.kind);
+        if (this.isDouble == other.isDouble)
+            return ((Comparable)this.value).compareTo(other.value);
+        BigDecimal thisDec  = this.isDouble  ? BigDecimal.valueOf((Double) this.value)  : (BigDecimal)this.value;
+        BigDecimal otherDec = other.isDouble ? BigDecimal.valueOf((Double) other.value) : (BigDecimal)other.value;
+        return thisDec.compareTo(otherDec);
+    }
+
+    public Number value()
+    {
+        return value;
+    }
+
+    public Number value(Unit unit)
+    {
+        return unit.fromStorageUnitValue(value);
+    }
+
+    /* Quantity implement Number, so most can can just pass this along without knowing. */
+    @Override
+    public int intValue()
+    {
+        return value.intValue();
+    }
+
+    @Override
+    public long longValue()
+    {
+        return value.longValue();
+    }
+
+    @Override
+    public float floatValue()
+    {
+        return value.floatValue();
+    }
+
+    @Override
+    public double doubleValue()
+    {
+        return value.doubleValue();
+    }
+
+
+    /*** PARSE ***/
+
+    private static final String NUMBER_REGEX = "(?<number>[+\\-]?(?<digits>\\d*([.]\\d*)?)(?:[Ee][+\\-]?\\d+)?)";
+
+    // UCUM units can be pretty complicated, but we only use a small subset for now
+    private static final String SIMPLE_UNIT_REGEX = "(?<unit>[a-zA-Zμℓ]+)";
+    // private static final String COMPLEX_UNIT ="(?<unit>[\\[/a-zA-Z°μℓ][\\[\\]_./a-zA-Z0-9°μℓ])?"; // unit contains []_./azAZ09°μ
+
+//    private static final Pattern pattern = Pattern.compile(NUMBER);
+    private static final Pattern pattern = Pattern.compile("^" + NUMBER_REGEX + "\\s*" + SIMPLE_UNIT_REGEX + "?$");
+
+
+    private static Quantity parse(@NotNull String s) throws ConversionException
+    {
+        return parse(s, Unit.no_unit);
+    }
+
+
+    /** The defaultUnit has two purposes 1) define the expected KindOfQuantity 2) select a Unit if it is not explicit in the source */
+    private static Quantity parse(@NotNull String s, @NotNull Unit defaultUnit) throws ConversionException
+    {
+        // We could probably create a real lexer/parser here, but we only need to be able to parse units we support
+        // FIRST, check if there is a space
+        s = s.trim();
+        var split = s.indexOf(' ');
+        String valuePart=null;
+        String unitPart=null;
+        if (split > 0)
+        {
+            valuePart = s.substring(0, split);
+            unitPart = s.substring(split+1);
+        }
+        else
+        {
+            var m = pattern.matcher(s);
+            if (m.matches())
+            {
+                String digits = m.group("digits");
+                // there should be digits before or after the "." (this check avoids needing a more complicated regex)
+                if (!".".equals(digits) && !"".equals(digits))
+                {
+                    valuePart = m.group("number");
+                    if (m.namedGroups().containsKey("unit"))
+                        unitPart = m.group("unit");
+                }
+            }
+        }
+
+        if (StringUtils.isBlank(valuePart))
+            throw new ConversionException("Could not parse number");
+
+        try
+        {
+            Number value = StringUtils.containsAny(valuePart,"eE") ?
+                    Double.valueOf(valuePart) :
+                    new BigDecimal(valuePart);
+            var unit = StringUtils.isBlank(unitPart) ? defaultUnit : Unit.fromName(unitPart);
+            if (null == unit)
+                unit = Unit.no_unit;
+            if (defaultUnit!=Unit.no_unit && !defaultUnit.kindOfQuantity.accept(unit))
+                throw new ConversionException("Quantity is of wrong type: expected " + defaultUnit.kindOfQuantity.getName() + " found " + unit);
+            return Quantity.of(value, unit);
+        }
+        catch (IllegalArgumentException x)
+        {
+            throw new ConversionException("could not parse", x);
+        }
+    }
+
+
+    /*** CONVERSION **/
+
+    public abstract static class Mass_pg extends Quantity {}
+    public abstract static class Mass_ng extends Quantity {}
+    public abstract static class Mass_ug extends Quantity {}
+    public abstract static class Mass_mg extends Quantity {}
+    public abstract static class Mass_g extends Quantity {}
+    public abstract static class Mass_kg extends Quantity {}
+    public abstract static class Mass_Mg extends Quantity {}
+
+    public abstract static class Volume_pl extends Quantity {}
+    public abstract static class Volume_nl extends Quantity {}
+    public abstract static class Volume_ul extends Quantity {}
+    public abstract static class Volume_ml extends Quantity {}
+    public abstract static class Volume_l extends Quantity {}
+    public abstract static class Volume_kl extends Quantity {}
+    public abstract static class Volume_Ml extends Quantity {}
+
+    public abstract static class Volume extends Quantity
+    {
+    }
+
+
+    // convert (ala BeanUtils.Converter to Quantity
+    public static Quantity convert(Object o, Unit unit)
+    {
+        if (null == o)
+            return null;
+        if (o instanceof Quantity q)
+        {
+            if (q.kind == unit.kindOfQuantity)
+                return q;
+            throw new ConversionException("Cannot convert " + q.format() + " to " + unit);
+        }
+        if (o instanceof Number n)
+        {
+            return Quantity.of(n, unit);
+        }
+        return Quantity.parse(String.valueOf(o), unit);
+    }
+
+
+    public static Converter converterFor(Unit unit)
+    {
+        return new Converter()
+        {
+            @Override
+            public <T> T convert(Class<T> aClass, Object o)
+            {
+                return (T)Quantity.convert(o, unit);
+            }
+        };
+    }
+
+    static void registerQuantityConverters()
+    {
+        for (Unit unit : Unit.values())
+            ConvertUtils.register(converterFor(unit), unit.getQuantityClass());
+    }
+
+    static
+    {
+        registerQuantityConverters();
+    }
+
+
+    /*** TEST ***/
+
+    public static class TestCase extends Assert
+    {
+        void failToParse(String s)
+        {
+            try
+            {
+                parse(s);
+                fail("expected exception for " + s);
+            }
+            catch (ConversionException x)
+            {
+                // YEAH
+            }
+        }
+
+        void failToParse(String s, Unit defaultUnit)
+        {
+            try
+            {
+                parse(s, defaultUnit);
+                fail("expected exception for " + s);
+            }
+            catch (ConversionException x)
+            {
+                // YEAH
+            }
+        }
+
+        @Test
+        public void testParse()
+        {
+            assertEquals(Quantity.of(1,g), parse("1", g));
+            assertEquals(Quantity.of(1,g), parse("1g"));
+            assertEquals(Quantity.of(1,g), parse("0.001kg"));
+            assertEquals(parse("1000mg"), parse("0.001kg"));
+
+            failToParse("kg");
+            failToParse("124xyz");
+            failToParse("g100");
+
+            failToParse("1g", Unit.l);
+        }
+
+        @Test
+        public void testPattern()
+        {
+            // no exponents
+            assertEquals(0.1, Double.valueOf(".1"), 0.0);
+            assertEquals(0.1, Double.valueOf("+.1"), 0.0);
+            assertEquals(-0.1, Double.valueOf("-.1"), 0.0);
+            assertTrue(pattern.matcher("1").matches());
+            assertTrue(pattern.matcher("+1").matches());
+            assertTrue(pattern.matcher("-1").matches());
+            assertTrue(pattern.matcher("1.").matches());
+            assertTrue(pattern.matcher("+1.").matches());
+            assertTrue(pattern.matcher("-1.").matches());
+            assertTrue(pattern.matcher(".2").matches());
+            assertTrue(pattern.matcher("+.2").matches());
+            assertTrue(pattern.matcher("-.2").matches());
+
+            // no digits
+            assertFalse(pattern.matcher("+").matches());
+            assertFalse(pattern.matcher(".").matches());
+            assertFalse(pattern.matcher("-").matches());
+            assertFalse(pattern.matcher("+e1").matches());
+
+            //exponents
+            assertEquals(0.1e2, Double.valueOf(".1e2"), 0.0);
+            assertTrue(pattern.matcher(".1e2").matches());
+            assertTrue(pattern.matcher("1.23e4").matches());
+            assertTrue(pattern.matcher("1.23E4").matches());
+            assertTrue(pattern.matcher("+1.23E4").matches());
+            assertTrue(pattern.matcher("-1.23E-4").matches());
+
+            // units
+            assertTrue(pattern.matcher("1.23μF").matches());
+            assertTrue(pattern.matcher("1.2e3 mℓ").matches());
+        }
+
+
+        @Test
+        public void testConversion()
+        {
+            Quantity q;
+            registerQuantityConverters();
+
+            q = (Quantity)ConvertUtils.convert("1.234kg", Quantity.Mass_g.class);
+            assertEquals(q.getClass(), Quantity.class);
+            assertEquals(new Quantity(KindOfQuantity.Mass, 1234d), q);
+
+            q = (Quantity)ConvertUtils.convert("1234", Quantity.Mass_g.class);
+            assertEquals(q.getClass(), Quantity.class);
+            assertEquals(new Quantity(KindOfQuantity.Mass, 1234d), q);
+        }
+    }
+}
diff --git a/api/src/org/labkey/api/ontology/Unit.java b/api/src/org/labkey/api/ontology/Unit.java
new file mode 100644
index 00000000000..9576913036d
--- /dev/null
+++ b/api/src/org/labkey/api/ontology/Unit.java
@@ -0,0 +1,171 @@
+package org.labkey.api.ontology;
+
+import lombok.Getter;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.HashMap;
+import java.util.function.Function;
+
+public enum Unit
+{
+    no_unit(KindOfQuantity.Count, null, 1.0, "",
+            Quantity.class,
+            "unit", "units"),
+
+    // UCUM prefers "l", but "L" is also common and already supported by inventory (sorry Lambert)
+    l(KindOfQuantity.Volume, null, 10e0, "l",
+            Quantity.Volume_l.class,
+            "liter", "liters",
+            "L", "ℓ", "litre", "liters"),
+    // is it better to include these little used units, to avoid future case-sensitivity problems?
+    Ml(KindOfQuantity.Volume, l, 10e3, "Ml",
+            Quantity.Volume_Ml.class,
+            "megaliter", "megaliters",
+            "ML", "megalitre", "megalitres"),
+    kl(KindOfQuantity.Volume, l, 10e3, "kl",
+            Quantity.Volume_kl.class,
+            "kiloliter", "kiloliters",
+            "kL", "kilolitre", "kilolitres"),
+    ml(KindOfQuantity.Volume, l, 10e-3, "ml",
+            Quantity.Volume_ml.class,
+            "milliliter", "milliliters",
+            "mL", "millilitre", "millilitres"),
+    ul(KindOfQuantity.Volume, l, 10e-6, "ul",
+            Quantity.Volume_ul.class,
+            "microliter", "microliters",
+            "uL", "μl", "μL", "microlitre", "microlitres"),
+    nl(KindOfQuantity.Volume, l, 10e-9, "nl",
+            Quantity.Volume_nl.class,
+            "nanoliter", "nanoliters",
+            "nL", "nanolitre", "nanolitres"),
+    pl(KindOfQuantity.Volume, l, 10e-12, "pl",
+            Quantity.Volume_pl.class,
+            "picoliter", "picoliters",
+            "pL", "picolitre", "picolitres"),
+
+    g(KindOfQuantity.Mass, null, 10e0, "g",
+            Quantity.Mass_g.class,
+            "gram", "grams"),
+    Mg(KindOfQuantity.Mass, g, 10e6, "Mg",
+            Quantity.Mass_Mg.class,
+            "megagram", "megagrams",
+            "tonne", "tonnes"),
+    kg(KindOfQuantity.Mass, g, 10e3, "kg",
+            Quantity.Mass_kg.class,
+            "kilogram", "kilograms"),
+    mg(KindOfQuantity.Mass, g, 10e-3, "mg",
+            Quantity.Mass_mg.class,
+            "milligram", "milligrams"),
+    ug(KindOfQuantity.Mass, g, 10e-6, "ug",
+            Quantity.Mass_ug.class,
+            "microgram", "micrograms",
+        "μg"),
+    ng(KindOfQuantity.Mass, g, 10e-9, "ng",
+            Quantity.Mass_ng.class,
+            "nanogram", "nanograms"),
+    pg(KindOfQuantity.Mass, g, 10e-12, "pg",
+            Quantity.Mass_pg.class,
+            "picogram", "picograms");
+
+
+    @Getter
+    final @NotNull KindOfQuantity kindOfQuantity;
+    final @NotNull Unit base;
+    final @NotNull String print;
+    // this is not a 'real' class, but is used for ConvertHelper binding
+    @Getter
+    final @NotNull Class<? extends Quantity> quantityClass;
+    final @NotNull String singular;
+    final @NotNull String plural;
+    final String[] otherNames;
+    final double value;
+
+    Unit(KindOfQuantity kind, Unit base, double value, @NotNull String printName,
+         Class<? extends Quantity> quantityClass,
+         @NotNull String singular, @NotNull String plural, String... otherNames)
+    {
+        this.kindOfQuantity = kind;
+        this.base = null == base ? this : base;
+        this.value = value;
+        this.print = printName;
+        this.quantityClass = quantityClass;
+        this.singular = singular;
+        this.plural = plural;
+        this.otherNames = null==otherNames || otherNames.length==0 ? null : otherNames;
+    }
+
+    public double toBaseUnitValue(double v)
+    {
+        return v * this.value;
+    }
+
+    public double fromBaseUnitValue(double v)
+    {
+        return v / this.value;
+    }
+
+    public Number toStorageUnitValue(Number v)
+    {
+        if (this == kindOfQuantity.getStorageUnit())
+            return v;
+        return convert(v.doubleValue(), this, kindOfQuantity.storageUnit);
+    }
+
+    public Number fromStorageUnitValue(Number v)
+    {
+        if (this == kindOfQuantity.getStorageUnit())
+            return v;
+        return convert(v.doubleValue(), kindOfQuantity.storageUnit, this);
+    }
+
+    @Override
+    public String toString()
+    {
+        return print;
+    }
+
+    static final HashMap<String,Unit> unitMap = new HashMap<>(Unit.values().length*10);
+    static
+    {
+        for (Unit unit : Unit.values())
+        {
+            unitMap.put(unit.print, unit);
+            unitMap.put(unit.singular, unit);
+            unitMap.put(unit.plural, unit);
+            if (null != unit.otherNames)
+                for (String name : unit.otherNames)
+                    unitMap.put(name, unit);
+        }
+    }
+
+
+    public static Unit fromName(String unitName)
+    {
+        Unit unit = unitMap.get(unitName);
+        if (null == unit)
+            unit = unitMap.get(unitName.toLowerCase());
+        return unit;
+    }
+
+    // don't assume multiplicative relation between units (e.g. Kelvin and Celsius)
+    static Function<Double,Double> convertFn(Unit from, Unit to)
+    {
+        if (from == to)
+            return Function.identity();
+        if (from.base != to.base)
+            throw new IllegalArgumentException("Can't convert " + from.name() + " to " + to.name());
+        return (x) -> to.fromBaseUnitValue(from.toBaseUnitValue(x));
+    }
+
+    static double convert(double value, Unit from, Unit to)
+    {
+        if (from.base != to.base)
+            throw new IllegalArgumentException("Can't convert " + from.name() + " to " + to.name());
+        return from==to ? value : to.fromBaseUnitValue(from.toBaseUnitValue(value));
+    }
+
+    public Quantity convert(Object value)
+    {
+        return Quantity.convert(value, this);
+    }
+}
diff --git a/experiment/src/org/labkey/experiment/api/SampleTypeUpdateServiceDI.java b/experiment/src/org/labkey/experiment/api/SampleTypeUpdateServiceDI.java
index b83ce6e6663..951210e1ab9 100644
--- a/experiment/src/org/labkey/experiment/api/SampleTypeUpdateServiceDI.java
+++ b/experiment/src/org/labkey/experiment/api/SampleTypeUpdateServiceDI.java
@@ -1954,7 +1954,8 @@ protected class SampleUnitsConvertColumn extends SimpleTranslator.SimpleConvertC
         {
             public SampleUnitsConvertColumn(String fieldName, int indexFrom, @Nullable JdbcType to)
             {
-                super(fieldName, indexFrom, to, true);
+                // TODO merge unit handling
+                super(fieldName, indexFrom, to, null,true);
             }
 
             @Override
@@ -1969,7 +1970,7 @@ protected class SampleAmountConvertColumn extends SimpleTranslator.SimpleConvert
         {
             public SampleAmountConvertColumn(String fieldName, int indexFrom, @Nullable JdbcType to)
             {
-                super(fieldName, indexFrom, to, true);
+                super(fieldName, indexFrom, to, null,true);
             }
 
             @Override
@@ -1985,7 +1986,7 @@ protected class AliquotRollupConvertColumn extends SimpleConvertColumn
 
             public AliquotRollupConvertColumn(String fieldName, @Nullable JdbcType to, int aliquotedFromColInd)
             {
-                super(fieldName, 0, to, true);
+                super(fieldName, 0, to, null,true);
                 this.aliquotedFromColInd = aliquotedFromColInd;
             }
 
diff --git a/query/src/org/labkey/query/sql/QNumber.java b/query/src/org/labkey/query/sql/QNumber.java
index 3876f7bcb50..712526779c0 100644
--- a/query/src/org/labkey/query/sql/QNumber.java
+++ b/query/src/org/labkey/query/sql/QNumber.java
@@ -33,7 +33,13 @@ public class QNumber extends QExpr implements IConstant
 
 	public QNumber(String s)
 	{
-		if (StringUtils.containsOnly(s,"0123456789"))
+		String substring = s;
+		if (s.startsWith("0x"))
+			setValue(convertInteger(s));
+		else if (s.startsWith("+") || s.startsWith("-"))
+			substring = s.substring(1);
+
+		if (StringUtils.containsOnly(substring,"0123456789"))
 			setValue(convertInteger(s));
 		else
 			setValue(convertDouble(s));
@@ -142,13 +148,37 @@ Number convertInteger(String s)
 
 	Number convertDouble(String s)
 	{
-		try
+		boolean floatish = false;
+		if (s.endsWith("f") || s.endsWith("F") || s.endsWith("d") || s.endsWith("D"))
 		{
-			return Double.parseDouble(s);
+			s = s.substring(0,s.length()-1);
+			floatish = true;
 		}
-		catch (NumberFormatException x)
+		if (StringUtils.containsAny(s, "eE"))
+			floatish = true;
+		if (floatish)
+		{
+			// try double first fall-back to decimal
+			try
+			{
+				return Double.parseDouble(s);
+			}
+			catch (NumberFormatException x)
+			{
+				return new BigDecimal(s);
+			}
+		}
+		else
 		{
-			return new BigDecimal(s);
+			// try decimal first fall-back to double
+			try
+			{
+				return new BigDecimal(s);
+			}
+			catch (NumberFormatException x)
+			{
+				return Double.parseDouble(s);
+			}
 		}
 	}
 
diff --git a/query/src/org/labkey/query/sql/QString.java b/query/src/org/labkey/query/sql/QString.java
index 5b3df398b4a..961b2af4e45 100644
--- a/query/src/org/labkey/query/sql/QString.java
+++ b/query/src/org/labkey/query/sql/QString.java
@@ -50,7 +50,7 @@ public String getValue()
     @Override
     public void appendSql(SqlBuilder builder, Query query)
     {
-        builder.appendStringLiteral(getValue());
+        builder.appendValue(getValue());
     }
 
     @Override

From 37f9cb9d91b4b7ae1878d63f5db14e8f1ff22292 Mon Sep 17 00:00:00 2001
From: Matthew Bellew <matthewb@labkey.com>
Date: Thu, 15 May 2025 15:41:21 -0700
Subject: [PATCH 02/18] imports

---
 api/src/org/labkey/api/data/TableViewForm.java | 2 --
 1 file changed, 2 deletions(-)

diff --git a/api/src/org/labkey/api/data/TableViewForm.java b/api/src/org/labkey/api/data/TableViewForm.java
index 3eb48be2f1c..269d00657d3 100644
--- a/api/src/org/labkey/api/data/TableViewForm.java
+++ b/api/src/org/labkey/api/data/TableViewForm.java
@@ -34,8 +34,6 @@
 import org.labkey.api.action.NullSafeBindException;
 import org.labkey.api.action.SpringActionController;
 import org.labkey.api.collections.CaseInsensitiveHashMap;
-import org.labkey.api.dataiterator.DataIteratorUtil;
-import org.labkey.api.query.QueryUpdateForm;
 import org.labkey.api.query.SchemaKey;
 import org.labkey.api.security.permissions.DeletePermission;
 import org.labkey.api.security.permissions.InsertPermission;

From 0bea798e184603e1d8c559c0111243d2b2a34800 Mon Sep 17 00:00:00 2001
From: labkey-matthewb <matthewb@labkey.com>
Date: Tue, 20 May 2025 13:22:57 -0700
Subject: [PATCH 03/18] merge patch

---
 .../api/data/ColumnRenderPropertiesImpl.java     | 16 +++++++++++++---
 api/src/org/labkey/api/data/DataColumn.java      | 12 ++++++++++--
 api/src/org/labkey/api/data/TableViewForm.java   | 10 +++++-----
 .../api/dataiterator/SimpleTranslator.java       |  4 ++--
 .../org/labkey/api/ontology/KindOfQuantity.java  |  2 +-
 api/src/org/labkey/api/ontology/Unit.java        |  4 ++--
 .../api/view/TypeAheadSelectDisplayColumn.java   |  8 ++++++--
 7 files changed, 39 insertions(+), 17 deletions(-)

diff --git a/api/src/org/labkey/api/data/ColumnRenderPropertiesImpl.java b/api/src/org/labkey/api/data/ColumnRenderPropertiesImpl.java
index cdc63915ca6..ada1ed96843 100644
--- a/api/src/org/labkey/api/data/ColumnRenderPropertiesImpl.java
+++ b/api/src/org/labkey/api/data/ColumnRenderPropertiesImpl.java
@@ -790,9 +790,19 @@ public Class<?> getJavaClass(boolean isNullable)
         boolean isNumeric;
         PropertyType pt = getPropertyType();
         if (pt != null)
-            return pt.getJavaType();
-
-        return getJdbcType().getJavaClass(isNullable);
+        {
+            ret = pt.getJavaType();
+            isNumeric = pt.getJdbcType().isNumeric();
+        }
+        else
+        {
+            ret = getJdbcType().getJavaClass(isNullable);
+            isNumeric = getJdbcType().isNumeric();
+        }
+        Unit unit = getDisplayUnit();
+        if (isNumeric && null != unit)
+           return unit.getQuantityClass();
+        return ret;
     }
 
     @Override
diff --git a/api/src/org/labkey/api/data/DataColumn.java b/api/src/org/labkey/api/data/DataColumn.java
index 0d0315fa4a1..38892070405 100644
--- a/api/src/org/labkey/api/data/DataColumn.java
+++ b/api/src/org/labkey/api/data/DataColumn.java
@@ -27,6 +27,8 @@
 import org.labkey.api.exp.property.PropertyService;
 import org.labkey.api.gwt.client.DefaultValueType;
 import org.labkey.api.gwt.client.model.PropertyValidatorType;
+import org.labkey.api.ontology.Quantity;
+import org.labkey.api.ontology.Unit;
 import org.labkey.api.query.DetailsURL;
 import org.labkey.api.query.FieldKey;
 import org.labkey.api.query.QueryParseException;
@@ -608,12 +610,18 @@ protected String getSelectInputDisplayValue(NamedObject entry)
         return entry.getObject().toString();
     }
 
-    protected String getStringValue(Object value, boolean disabledInput)
+    protected String getStringValue(Object value, Unit unit, boolean disabledInput)
     {
         String strVal = "";
         //UNDONE: Should use output format here.
         if (null != value)
         {
+            if (unit != null && value instanceof Number num)
+            {
+                Quantity quantity = (value instanceof Quantity q) ? q : unit.getKindOfQuantity().toQuantity(num);
+                value = quantity.value(unit);
+            }
+
             // 4934: Don't render form input values with formatter since we don't parse formatted inputs on post.
             // For now, we can at least render disabled inputs with formatting since a
             // hidden input with the actual value is emitted for disabled items.
@@ -642,7 +650,7 @@ public void renderInputHtml(RenderContext ctx, Writer out, Object value) throws
 
         boolean disabledInput = isDisabledInput(ctx);
         final String formFieldName = getFormFieldName(ctx);
-        String strVal = getStringValue(value, disabledInput);
+        String strVal = getStringValue(value, _boundColumn.getDisplayUnit(), disabledInput);
 
         if (_boundColumn.isAutoIncrement())
         {
diff --git a/api/src/org/labkey/api/data/TableViewForm.java b/api/src/org/labkey/api/data/TableViewForm.java
index 1ed90ded2e6..12289622597 100644
--- a/api/src/org/labkey/api/data/TableViewForm.java
+++ b/api/src/org/labkey/api/data/TableViewForm.java
@@ -35,7 +35,6 @@
 import org.labkey.api.action.SpringActionController;
 import org.labkey.api.collections.CaseInsensitiveHashMap;
 import org.labkey.api.ontology.Quantity;
-import org.labkey.api.ontology.Unit;
 import org.labkey.api.query.SchemaKey;
 import org.labkey.api.security.permissions.DeletePermission;
 import org.labkey.api.security.permissions.InsertPermission;
@@ -410,22 +409,23 @@ protected void _populateValues(BindException errors)
 
         for (String propName : keys)
         {
+            ColumnInfo col = getColumnByFormFieldName(propName);
             String str = _stringValues.get(propName);
             String caption = _dynaClass.getPropertyCaption(propName);
+            Class<?> propType = null;
 
             if (StringUtils.isEmpty(str))
                 str = null;
 
-            Class<?> propType = null;
-
             try
             {
+
                 if (null != str)
                 {
                     Object val;
-                    if (null != defaultUnit)
+                    if (null != col && null != col.getKindOfQuantity())
                     {
-                        val = Quantity.convert(str, defaultUnit);
+                        val = Quantity.convert(str, col.getDisplayUnit());
                     }
                     else
                     {
diff --git a/api/src/org/labkey/api/dataiterator/SimpleTranslator.java b/api/src/org/labkey/api/dataiterator/SimpleTranslator.java
index 29e0f0a45b6..58dc95e2cbc 100644
--- a/api/src/org/labkey/api/dataiterator/SimpleTranslator.java
+++ b/api/src/org/labkey/api/dataiterator/SimpleTranslator.java
@@ -1307,9 +1307,9 @@ private SimpleConvertColumn createConvertColumn(@NotNull ColumnInfo col, int fro
 
         SimpleConvertColumn c;
         if (PropertyType.STRING == pt && (trimString || trimStringRight))
-            c = new PropertyConvertAndTrimColumn(name, fromIndex, mvIndex, mv, pt, type, !trimString);
+            c = new PropertyConvertAndTrimColumn(name, fromIndex, mvIndex, mv, pt, type, col.getDisplayUnit(), !trimString);
         else
-            c = new PropertyConvertColumn(name, fromIndex, mvIndex, mv, pt, type);
+            c = new PropertyConvertColumn(name, fromIndex, mvIndex, mv, pt, type, col.getDisplayUnit());
 
         ForeignKey fk = col.getFk();
         if (fk != null && _context.isAllowImportLookupByAlternateKey() && fk.allowImportByAlternateKey())
diff --git a/api/src/org/labkey/api/ontology/KindOfQuantity.java b/api/src/org/labkey/api/ontology/KindOfQuantity.java
index f91979f56af..399abef92ff 100644
--- a/api/src/org/labkey/api/ontology/KindOfQuantity.java
+++ b/api/src/org/labkey/api/ontology/KindOfQuantity.java
@@ -38,7 +38,7 @@ List<Unit> getCommonUnits()
         @Override
         List<Unit> getCommonUnits()
         {
-            return List.of(Unit.no_unit);
+            return List.of(Unit.count);
         }
     };
 
diff --git a/api/src/org/labkey/api/ontology/Unit.java b/api/src/org/labkey/api/ontology/Unit.java
index 9576913036d..3e92f011ef9 100644
--- a/api/src/org/labkey/api/ontology/Unit.java
+++ b/api/src/org/labkey/api/ontology/Unit.java
@@ -8,9 +8,9 @@
 
 public enum Unit
 {
-    no_unit(KindOfQuantity.Count, null, 1.0, "",
+    count(KindOfQuantity.Count, null, 1.0, "",
             Quantity.class,
-            "unit", "units"),
+            "count", "count"),
 
     // UCUM prefers "l", but "L" is also common and already supported by inventory (sorry Lambert)
     l(KindOfQuantity.Volume, null, 10e0, "l",
diff --git a/api/src/org/labkey/api/view/TypeAheadSelectDisplayColumn.java b/api/src/org/labkey/api/view/TypeAheadSelectDisplayColumn.java
index 20a3c650244..8570151a927 100644
--- a/api/src/org/labkey/api/view/TypeAheadSelectDisplayColumn.java
+++ b/api/src/org/labkey/api/view/TypeAheadSelectDisplayColumn.java
@@ -22,6 +22,7 @@
 import org.labkey.api.data.DisplayColumnFactory;
 import org.labkey.api.data.ForeignKey;
 import org.labkey.api.data.RenderContext;
+import org.labkey.api.ontology.Unit;
 import org.labkey.api.util.PageFlowUtil;
 import org.labkey.api.util.UniqueID;
 
@@ -48,7 +49,10 @@ public TypeAheadSelectDisplayColumn(ColumnInfo col, Integer maxRows)
     @Override
     public void renderInputHtml(RenderContext ctx, Writer out, Object value) throws IOException
     {
-        ForeignKey fk = getBoundColumn().getFk();
+        ColumnInfo boundColumn = getBoundColumn();
+        ForeignKey fk = boundColumn.getFk();
+        Unit unit = boundColumn.getDisplayUnit();
+
         // currently only supported for lookup columns with a defined schema/query
         if (fk == null)
         {
@@ -58,7 +62,7 @@ public void renderInputHtml(RenderContext ctx, Writer out, Object value) throws
 
         String formFieldName = getFormFieldName(ctx);
         boolean disabledInput = isDisabledInput(ctx);
-        String strVal = getStringValue(value, disabledInput);
+        String strVal = getStringValue(value, unit, disabledInput);
         String renderId = "query-select-div-" + UniqueID.getRequestScopedUID(ctx.getRequest());
 
         StringBuilder sb = new StringBuilder();

From 345c14623df08ec6bb47858cbdb174334b340b64 Mon Sep 17 00:00:00 2001
From: labkey-matthewb <matthewb@labkey.com>
Date: Tue, 20 May 2025 13:31:29 -0700
Subject: [PATCH 04/18] merge patch

---
 api/src/org/labkey/api/ontology/Unit.java | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/api/src/org/labkey/api/ontology/Unit.java b/api/src/org/labkey/api/ontology/Unit.java
index 3e92f011ef9..3e2eca900b2 100644
--- a/api/src/org/labkey/api/ontology/Unit.java
+++ b/api/src/org/labkey/api/ontology/Unit.java
@@ -8,6 +8,10 @@
 
 public enum Unit
 {
+    no_unit(KindOfQuantity.Count, null, 1.0, "",
+            Quantity.class,
+            "no units", "no units"),
+
     count(KindOfQuantity.Count, null, 1.0, "",
             Quantity.class,
             "count", "count"),

From e37d898e33d6d7a9eada0f60708f7499702ab423 Mon Sep 17 00:00:00 2001
From: labkey-matthewb <matthewb@labkey.com>
Date: Tue, 20 May 2025 14:10:11 -0700
Subject: [PATCH 05/18] java 17

---
 .../org/labkey/api/data/DisplayColumn.java    | 33 ++++++++++++-------
 api/src/org/labkey/api/ontology/Quantity.java | 11 +++++--
 2 files changed, 30 insertions(+), 14 deletions(-)

diff --git a/api/src/org/labkey/api/data/DisplayColumn.java b/api/src/org/labkey/api/data/DisplayColumn.java
index 00dd72f0b9b..a7af26f9e0c 100644
--- a/api/src/org/labkey/api/data/DisplayColumn.java
+++ b/api/src/org/labkey/api/data/DisplayColumn.java
@@ -525,25 +525,34 @@ protected final String formatValue(RenderContext ctx, final Object value, String
 
         if (null != expr && expr.canRender(ctx.getFieldMap().keySet()))
         {
+            // TODO handle Quantity values here?
             return expr.eval(ctx);
         }
 
         @NotNull String formattedString;
-        if (null != format)
+        if (null != displayUnit && value instanceof Number)
+        {
+            Quantity q = (value instanceof Quantity) ?
+                    (Quantity)value :
+                    displayUnit.getKindOfQuantity().toQuantity((Number)value);
+            /* DISPLAY WITH UNIT SUFFIX
+            if (null == format)
+                formattedString = q.format(displayUnit);
+            else
+                formattedString = q.format(displayUnit, format);\
+             */
+            /* DISPLAY WITHOUT UNIT SUFFIX */
+            var doubleValue = ConvertUtils.convert(q.doubleValue(displayUnit));
+            if (null == format)
+                formattedString = ConvertUtils.convert(doubleValue);
+            else
+                formattedString = format.format(value);
+        }
+        else if (null != format)
         {
             try
             {
-                if (null != displayUnit && value instanceof Number number)
-                {
-                    Quantity q = (value instanceof Quantity) ?
-                            (Quantity)value :
-                            displayUnit.getKindOfQuantity().toQuantity(number);
-                    formattedString = q.format(displayUnit, format);
-                }
-                else
-                {
-                    formattedString = format.format(value);
-                }
+                formattedString = format.format(value);
             }
             catch (IllegalArgumentException e)
             {
diff --git a/api/src/org/labkey/api/ontology/Quantity.java b/api/src/org/labkey/api/ontology/Quantity.java
index e397cb1cd26..d98f33cf490 100644
--- a/api/src/org/labkey/api/ontology/Quantity.java
+++ b/api/src/org/labkey/api/ontology/Quantity.java
@@ -113,6 +113,14 @@ protected Quantity(@NotNull KindOfQuantity kind, Double value, Unit from)
         assert isDouble || this.value instanceof BigDecimal;
     }
 
+    public double doubleValue(Unit unit)
+    {
+        if (unit == kind.getStorageUnit())
+            return value.doubleValue();
+        else
+            return Unit.convert(value.doubleValue(), kind.getStorageUnit(), unit);
+    }
+
     public String format()
     {
         return format(kind.getDefaultDisplayUnit());
@@ -201,7 +209,6 @@ public double doubleValue()
     private static final String SIMPLE_UNIT_REGEX = "(?<unit>[a-zA-Zμℓ]+)";
     // private static final String COMPLEX_UNIT ="(?<unit>[\\[/a-zA-Z°μℓ][\\[\\]_./a-zA-Z0-9°μℓ])?"; // unit contains []_./azAZ09°μ
 
-//    private static final Pattern pattern = Pattern.compile(NUMBER);
     private static final Pattern pattern = Pattern.compile("^" + NUMBER_REGEX + "\\s*" + SIMPLE_UNIT_REGEX + "?$");
 
 
@@ -235,7 +242,7 @@ private static Quantity parse(@NotNull String s, @NotNull Unit defaultUnit) thro
                 if (!".".equals(digits) && !"".equals(digits))
                 {
                     valuePart = m.group("number");
-                    if (m.namedGroups().containsKey("unit"))
+                    if (StringUtils.isNotBlank(m.group("unit"))) //m.namedGroups().containsKey("unit"))
                         unitPart = m.group("unit");
                 }
             }

From 03276355398385b5d19b45bfe845db6ae344e424 Mon Sep 17 00:00:00 2001
From: labkey-matthewb <matthewb@labkey.com>
Date: Tue, 20 May 2025 15:46:48 -0700
Subject: [PATCH 06/18] update expected result

---
 query/src/org/labkey/query/sql/SqlParser.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/query/src/org/labkey/query/sql/SqlParser.java b/query/src/org/labkey/query/sql/SqlParser.java
index c458a00116c..441ef0f6e80 100644
--- a/query/src/org/labkey/query/sql/SqlParser.java
+++ b/query/src/org/labkey/query/sql/SqlParser.java
@@ -1993,8 +1993,8 @@ public static class SqlParserTestCase extends Assert
             new Pair<>("'this ' || 'that'", JdbcType.VARCHAR),
             new Pair<>("1 || ' plus ' || 2", JdbcType.VARCHAR),
             new Pair<>("1 + 2", JdbcType.INTEGER),
-            new Pair<>("1.0 + 2.1", JdbcType.DOUBLE),
-            new Pair<>("1 + 2.1", JdbcType.DOUBLE),
+            new Pair<>("1.0 + 2.1", JdbcType.DECIMAL),
+            new Pair<>("1 + 2.1", JdbcType.DECIMAL),
             new Pair<>("ROUND(0.0,1)", JdbcType.DOUBLE),
             new Pair<>("1 + ROUND(0.0,1)", JdbcType.DOUBLE),
             new Pair<>("CASE WHEN TRUE THEN ROUND(0.0,1) ELSE ROUND(0.0,1) END", JdbcType.DOUBLE)

From c3441885cd25d8b29c249aef659b19bb52c5b01b Mon Sep 17 00:00:00 2001
From: Matthew Bellew <matthewb@labkey.com>
Date: Thu, 22 May 2025 15:33:49 -0700
Subject: [PATCH 07/18] build problem

---
 api/src/org/labkey/api/ontology/Quantity.java | 4 ++--
 api/src/org/labkey/api/ontology/Unit.java     | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/api/src/org/labkey/api/ontology/Quantity.java b/api/src/org/labkey/api/ontology/Quantity.java
index d98f33cf490..5cbecc86fc1 100644
--- a/api/src/org/labkey/api/ontology/Quantity.java
+++ b/api/src/org/labkey/api/ontology/Quantity.java
@@ -278,7 +278,7 @@ public abstract static class Mass_ug extends Quantity {}
     public abstract static class Mass_mg extends Quantity {}
     public abstract static class Mass_g extends Quantity {}
     public abstract static class Mass_kg extends Quantity {}
-    public abstract static class Mass_Mg extends Quantity {}
+    public abstract static class Mass_Megag extends Quantity {}
 
     public abstract static class Volume_pl extends Quantity {}
     public abstract static class Volume_nl extends Quantity {}
@@ -286,7 +286,7 @@ public abstract static class Volume_ul extends Quantity {}
     public abstract static class Volume_ml extends Quantity {}
     public abstract static class Volume_l extends Quantity {}
     public abstract static class Volume_kl extends Quantity {}
-    public abstract static class Volume_Ml extends Quantity {}
+    public abstract static class Volume_Megal extends Quantity {}
 
     public abstract static class Volume extends Quantity
     {
diff --git a/api/src/org/labkey/api/ontology/Unit.java b/api/src/org/labkey/api/ontology/Unit.java
index 3e2eca900b2..b741e7d4fb9 100644
--- a/api/src/org/labkey/api/ontology/Unit.java
+++ b/api/src/org/labkey/api/ontology/Unit.java
@@ -23,7 +23,7 @@ public enum Unit
             "L", "ℓ", "litre", "liters"),
     // is it better to include these little used units, to avoid future case-sensitivity problems?
     Ml(KindOfQuantity.Volume, l, 10e3, "Ml",
-            Quantity.Volume_Ml.class,
+            Quantity.Volume_Megal.class,
             "megaliter", "megaliters",
             "ML", "megalitre", "megalitres"),
     kl(KindOfQuantity.Volume, l, 10e3, "kl",
@@ -51,7 +51,7 @@ public enum Unit
             Quantity.Mass_g.class,
             "gram", "grams"),
     Mg(KindOfQuantity.Mass, g, 10e6, "Mg",
-            Quantity.Mass_Mg.class,
+            Quantity.Mass_Megag.class,
             "megagram", "megagrams",
             "tonne", "tonnes"),
     kg(KindOfQuantity.Mass, g, 10e3, "kg",

From a09337c8b46c62026249e854ee083d08a8a6c777 Mon Sep 17 00:00:00 2001
From: Matthew Bellew <matthewb@labkey.com>
Date: Thu, 22 May 2025 16:35:18 -0700
Subject: [PATCH 08/18] I wasn't really planning on commiting this for a while.
  But this makes conversion more consistent in a bunch of places.

ColumnRenderProperties.getConvertFn()
---
 .../api/data/ColumnRenderProperties.java      | 108 +++++++++++++++++-
 .../org/labkey/api/data/DisplayColumn.java    |  22 ++--
 api/src/org/labkey/api/ontology/Quantity.java |   8 +-
 .../api/query/AbstractQueryUpdateService.java |   2 +-
 .../api/query/DefaultQueryUpdateService.java  |  14 +--
 5 files changed, 134 insertions(+), 20 deletions(-)

diff --git a/api/src/org/labkey/api/data/ColumnRenderProperties.java b/api/src/org/labkey/api/data/ColumnRenderProperties.java
index 99c8f8dacbc..e6d5f2d3ec7 100644
--- a/api/src/org/labkey/api/data/ColumnRenderProperties.java
+++ b/api/src/org/labkey/api/data/ColumnRenderProperties.java
@@ -15,6 +15,7 @@
  */
 package org.labkey.api.data;
 
+import org.apache.commons.beanutils.ConvertUtils;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.labkey.api.exp.PropertyType;
@@ -22,14 +23,18 @@
 import org.labkey.api.gwt.client.FacetingBehaviorType;
 import org.labkey.api.ontology.KindOfQuantity;
 import org.labkey.api.ontology.OntologyService;
+import org.labkey.api.ontology.Quantity;
 import org.labkey.api.ontology.Unit;
 import org.labkey.api.query.FieldKey;
 import org.labkey.api.util.StringExpression;
+import org.labkey.api.util.logging.LogHelper;
 
 import java.io.File;
 import java.math.BigDecimal;
+import java.text.DecimalFormatSymbols;
 import java.util.Date;
 import java.util.Set;
+import java.util.function.Function;
 
 import static org.labkey.api.ontology.OntologyService.conceptCodeConceptURI;
 
@@ -201,7 +206,7 @@ else if (Date.class.isAssignableFrom(javaClass))
      */
     boolean isScannable();
 
-        /* Properties loaded by OntologyService */
+    /* Properties loaded by OntologyService */
 
     // any column can be annotated with PrincipalConceptCode
     default String getPrincipalConceptCode()
@@ -284,4 +289,105 @@ default String getDerivationDataScope()
     {
         return null;
     }
+
+
+    /**
+     * This Format can be used for low-level conversion of the type represented by this column.  It does handle
+     * basic numeric/date conversion including formats, and default display unit handling.  That's about it.
+     * It never produces HTML
+     * It does not handle compound/column formatting (missing values, oor, etc)
+     * It does not handle conditional formatting
+     * This method moves (most) of the work formerly done in DisplayColumn.formatValue() to a shared location (getFormat())
+     * Likewise for SimpleConvertColumn.simpleConvert() (getConvert())
+     */
+    @Transient
+    default Function<Object, String> getFormatFn()
+    {
+        return getDefaultFormatFn(getName(), getJavaObjectClass(), getDisplayUnit(), getFormat(), null);
+    }
+
+    @Transient
+    default Function<Object, String> getTsvFormatFn()
+    {
+        return getDefaultFormatFn(getName(), getJavaObjectClass(), getDisplayUnit(), getTsvFormatString(), DisplayColumn.tsvFormatSymbols);
+    }
+
+    @Transient
+    default Function<Object,Object> getConvertFn()
+    {
+        return getDefaultConvertFn(this);
+    }
+
+    static Function<Object, String> getDefaultFormatFn(String colName, Class javaObjectClass, final Unit displayUnit, String formatString, DecimalFormatSymbols dfs)
+    {
+        final var format = null==formatString ? null : DisplayColumn.createFormat(formatString, javaObjectClass, dfs);
+
+        if (null == format && null == displayUnit)
+        {
+            return (value) -> null==value ? "" : value instanceof String ? (String)value : ConvertUtils.convert(value);
+        }
+
+        return (value) ->
+        {
+            if (null == value)
+                return "";
+
+            @NotNull String formattedString;
+            if (null != displayUnit && value instanceof Number)
+            {
+                Quantity q = (value instanceof Quantity) ?
+                        (Quantity) value :
+                        displayUnit.getKindOfQuantity().toQuantity((Number) value);
+                var doubleValue = q.doubleValue(displayUnit);
+                if (null == format)
+                    formattedString = ConvertUtils.convert(doubleValue);
+                else
+                    formattedString = format.format(doubleValue);
+            }
+            else if (null != format)
+            {
+                try
+                {
+                    formattedString = format.format(value);
+                }
+                catch (IllegalArgumentException e)
+                {
+                    LogHelper.getLogger(ColumnRenderProperties.class, "Column metadata").warn("Unable to apply format to {} value \"{}\" for column \"{}\", likely a SQL type mismatch between XML metadata and actual ResultSet", value.getClass().getName(), value, colName);
+                    formattedString = ConvertUtils.convert(value);
+                }
+            }
+            else if (value instanceof String)
+            {
+                formattedString = (String) value;
+            }
+            else
+            {
+                formattedString = ConvertUtils.convert(value);
+            }
+
+            return formattedString;
+        };
+    }
+
+    /* empty string -> null */
+    static Function<Object,Object> getDefaultConvertFn(ColumnRenderProperties col)
+    {
+        final Class<?> javaClass = col.getJavaObjectClass();
+        final var defaultUnit = col.getDisplayUnit();
+        final @NotNull var jdbcType = col.getJdbcType();
+
+        if (null == defaultUnit)
+        {
+            return (value) ->
+            {
+                // quick check for unnecessary conversion
+                if (value == null || javaClass == value.getClass())
+                    return value;
+                if (value instanceof CharSequence)
+                    ConvertUtils.convert(value.toString(), javaClass);
+                return jdbcType.convert(value);
+            };
+        }
+        return defaultUnit::convert;
+    }
 }
diff --git a/api/src/org/labkey/api/data/DisplayColumn.java b/api/src/org/labkey/api/data/DisplayColumn.java
index bc61e912c96..5d2226d79ff 100644
--- a/api/src/org/labkey/api/data/DisplayColumn.java
+++ b/api/src/org/labkey/api/data/DisplayColumn.java
@@ -137,7 +137,9 @@ public int getRowSpan(RenderContext ctx)
         }
 
         @Override
-        public void addQueryColumns(Set<FieldKey> fieldKeys) {}
+        public void addQueryColumns(Set<FieldKey> fieldKeys)
+        {
+        }
 
         @Override
         public boolean shouldRenderInCurrentRow(RenderContext ctx)
@@ -230,7 +232,8 @@ public StringExpression getURLExpression()
         return _urlExpression;
     }
 
-    public boolean includeURL() {
+    public boolean includeURL()
+    {
         return _urlExpression != null || _url != null;
     }
 
@@ -287,7 +290,7 @@ public String renderURLTitle(RenderContext ctx)
         return _analyticsProviders;
     }
 
-    protected  void addAnalyticsProvider(@NotNull ColumnAnalyticsProvider analyticsProvider)
+    protected void addAnalyticsProvider(@NotNull ColumnAnalyticsProvider analyticsProvider)
     {
         _analyticsProviders.add(analyticsProvider);
     }
@@ -396,7 +399,8 @@ public void setFormatString(String formatString)
 
     // java 7 changed to using infinity symbols for formatting, which is challenging for tsv import/export
     // use old school "Infinity" for now
-    static DecimalFormatSymbols tsvFormatSymbols = new DecimalFormatSymbols();
+    static public DecimalFormatSymbols tsvFormatSymbols = new DecimalFormatSymbols();
+
     static
     {
         tsvFormatSymbols.setInfinity(String.valueOf(Double.POSITIVE_INFINITY));
@@ -412,13 +416,17 @@ public void setTsvFormatString(String formatString)
         _tsvFormat = createFormat(formatString, tsvFormatSymbols);
     }
 
-
     private Format createFormat(String formatString, @Nullable DecimalFormatSymbols dfs)
+    {
+        if (null == formatString)
+            return null;
+        return createFormat(formatString, getDisplayValueClass(), dfs);
+    }
+
+    public static Format createFormat(@Nullable String formatString, Class<?> valueClass, @Nullable DecimalFormatSymbols dfs)
     {
         if (null != formatString)
         {
-            Class<?> valueClass = getDisplayValueClass();
-
             try
             {
                 if (Boolean.class.isAssignableFrom(valueClass) || boolean.class.isAssignableFrom(valueClass))
diff --git a/api/src/org/labkey/api/ontology/Quantity.java b/api/src/org/labkey/api/ontology/Quantity.java
index 5cbecc86fc1..3aca9673ce2 100644
--- a/api/src/org/labkey/api/ontology/Quantity.java
+++ b/api/src/org/labkey/api/ontology/Quantity.java
@@ -141,10 +141,16 @@ public String format(Unit unit, Format format)
         return format.format(unit.fromStorageUnitValue(value)) + unit.print;
     }
 
+    /**
+     * Quantity extends Numeric so we kinda expect .toString() be a number.
+     * However, it's really important that quantity == ConvertUtils.convert(quantity.toString(), Quantity.class).
+     */
     @Override
     public String toString()
     {
-        return kind.getName() + ":" + format(kind.getStorageUnit());
+        var ret = format(kind.getStorageUnit());
+        assert this == ConvertUtils.convert(ret, this.getClass());
+        return ret;
     }
 
     @Override
diff --git a/api/src/org/labkey/api/query/AbstractQueryUpdateService.java b/api/src/org/labkey/api/query/AbstractQueryUpdateService.java
index 8b14f1c6878..40e9d2c468f 100644
--- a/api/src/org/labkey/api/query/AbstractQueryUpdateService.java
+++ b/api/src/org/labkey/api/query/AbstractQueryUpdateService.java
@@ -705,7 +705,7 @@ protected Map<String, Object> coerceTypes(Map<String, Object> row)
             {
                 try
                 {
-                    value = ConvertUtils.convert(value.toString(), col.getJavaObjectClass());
+                    value = col.getConvertFn().apply(value);
                 }
                 catch (ConversionException e)
                 {
diff --git a/api/src/org/labkey/api/query/DefaultQueryUpdateService.java b/api/src/org/labkey/api/query/DefaultQueryUpdateService.java
index ce2de00a17f..d1d2c1e1c43 100644
--- a/api/src/org/labkey/api/query/DefaultQueryUpdateService.java
+++ b/api/src/org/labkey/api/query/DefaultQueryUpdateService.java
@@ -836,18 +836,12 @@ protected Object convertColumnValue(ColumnInfo col, Object value, User user, Con
         // improve handling of conversion errors
         try
         {
-            switch (col.getJdbcType())
+            if (PropertyType.FILE_LINK == col.getPropertyType() && (value instanceof MultipartFile || value instanceof AttachmentFile))
             {
-                case DATE, TIME, TIMESTAMP:
-                    return value instanceof Date ? value : ConvertUtils.convert(value.toString(), Date.class);
-                default:
-                    if (PropertyType.FILE_LINK == col.getPropertyType() && (value instanceof MultipartFile || value instanceof AttachmentFile))
-                    {
-                        FileLike fl = (FileLike)_fileColumnValueMapping.saveFileColumnValue(user, c, fileLinkDirPath, col.getName(), value);
-                        value = fl.toNioPathForRead().toString();
-                    }
-                    return ConvertUtils.convert(value.toString(), col.getJdbcType().getJavaClass());
+                FileLike fl = (FileLike)_fileColumnValueMapping.saveFileColumnValue(user, c, fileLinkDirPath, col.getName(), value);
+                value = fl.toNioPathForRead().toString();
             }
+            return col.getConvertFn().apply(value);
         }
         catch (ConversionException e)
         {

From f2ed404c0cddf0716857e355e6bd64ad60788893 Mon Sep 17 00:00:00 2001
From: cnathe <cnathe@labkey.com>
Date: Tue, 5 Aug 2025 16:43:52 -0500
Subject: [PATCH 09/18] fixup after merge from develop

---
 api/src/org/labkey/api/query/DefaultQueryUpdateService.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/api/src/org/labkey/api/query/DefaultQueryUpdateService.java b/api/src/org/labkey/api/query/DefaultQueryUpdateService.java
index 2ac4a8254f6..2e33d3bb2b7 100644
--- a/api/src/org/labkey/api/query/DefaultQueryUpdateService.java
+++ b/api/src/org/labkey/api/query/DefaultQueryUpdateService.java
@@ -844,7 +844,7 @@ protected Object convertColumnValue(ColumnInfo col, Object value, User user, Con
                     FileLike fl = (FileLike)_fileColumnValueMapping.saveFileColumnValue(user, c, fileLinkDirPath, col.getName(), value);
                     value = fl.toNioPathForRead().toString();
                 }
-                value = ExpDataFileConverter.convert(value);
+                return ExpDataFileConverter.convert(value);
             }
             return col.getConvertFn().apply(value);
         }

From eafbf251a7b0e068a4a09184f09eeba74f124e8c Mon Sep 17 00:00:00 2001
From: cnathe <cnathe@labkey.com>
Date: Tue, 12 Aug 2025 11:29:59 -0500
Subject: [PATCH 10/18] Add QUANTITY_COLUMN_SUFFIX_TESTING experimental feature
 flag

---
 .../org/labkey/api/data/BaseColumnInfo.java   | 18 ++++++-----
 .../api/data/ColumnRenderProperties.java      | 31 +++++++++++--------
 api/src/org/labkey/api/settings/AppProps.java |  1 +
 .../labkey/experiment/ExperimentModule.java   |  3 +-
 4 files changed, 32 insertions(+), 21 deletions(-)

diff --git a/api/src/org/labkey/api/data/BaseColumnInfo.java b/api/src/org/labkey/api/data/BaseColumnInfo.java
index 5f203846267..e67bf3f5d3c 100644
--- a/api/src/org/labkey/api/data/BaseColumnInfo.java
+++ b/api/src/org/labkey/api/data/BaseColumnInfo.java
@@ -46,6 +46,8 @@
 import org.labkey.api.query.QueryParseException;
 import org.labkey.api.query.SchemaKey;
 import org.labkey.api.query.column.BuiltInColumnTypes;
+import org.labkey.api.settings.AppProps;
+import org.labkey.api.settings.OptionalFeatureService;
 import org.labkey.api.util.PageFlowUtil;
 import org.labkey.api.util.StringExpression;
 import org.labkey.api.util.StringExpressionFactory;
@@ -1356,15 +1358,17 @@ public static String labelFromName(String name)
         if (StringUtils.isBlank(name))
             return name;
 
-        //UNDONE This is just for testing the idea (let the DataRegion/DataColumn do this)
-        var index = name.indexOf("__");
-        if (index > 0)
+        // NOTE: This is just for testing (let the DataRegion/DataColumn do this)
+        if (OptionalFeatureService.get().isFeatureEnabled(AppProps.QUANTITY_COLUMN_SUFFIX_TESTING))
         {
-            String unit = name.substring(index + 2);
-            if (null != org.labkey.api.ontology.Unit.fromName(unit))
-                name = name.substring(0, index);
+            var index = name.indexOf("__");
+            if (index > 0)
+            {
+                String unit = name.substring(index + 2);
+                if (null != org.labkey.api.ontology.Unit.fromName(unit))
+                    name = name.substring(0, index);
+            }
         }
-        //UNDONE
 
         StringBuilder buf = new StringBuilder(name.length() + 10);
         char[] chars = new char[name.length()];
diff --git a/api/src/org/labkey/api/data/ColumnRenderProperties.java b/api/src/org/labkey/api/data/ColumnRenderProperties.java
index e6d5f2d3ec7..57b2a8ec140 100644
--- a/api/src/org/labkey/api/data/ColumnRenderProperties.java
+++ b/api/src/org/labkey/api/data/ColumnRenderProperties.java
@@ -26,6 +26,8 @@
 import org.labkey.api.ontology.Quantity;
 import org.labkey.api.ontology.Unit;
 import org.labkey.api.query.FieldKey;
+import org.labkey.api.settings.AppProps;
+import org.labkey.api.settings.OptionalFeatureService;
 import org.labkey.api.util.StringExpression;
 import org.labkey.api.util.logging.LogHelper;
 
@@ -263,20 +265,23 @@ default KindOfQuantity getKindOfQuantity()
 
     default Unit getDisplayUnit()
     {
-        if (!getJdbcType().isNumeric())
-            return null;
-        String name = getName();
-        var index = name.lastIndexOf("__");
-        if (index < 0)
-            return null;
-        var unitPart = name.substring(index+2);
-        try
-        {
-            return Unit.valueOf(unitPart);
-        }
-        catch (IllegalArgumentException x)
+        if (OptionalFeatureService.get().isFeatureEnabled(AppProps.QUANTITY_COLUMN_SUFFIX_TESTING))
         {
-            // pass
+            if (!getJdbcType().isNumeric())
+                return null;
+            String name = getName();
+            var index = name.lastIndexOf("__");
+            if (index < 0)
+                return null;
+            var unitPart = name.substring(index + 2);
+            try
+            {
+                return Unit.valueOf(unitPart);
+            }
+            catch (IllegalArgumentException x)
+            {
+                // pass
+            }
         }
         return null;
     }
diff --git a/api/src/org/labkey/api/settings/AppProps.java b/api/src/org/labkey/api/settings/AppProps.java
index a4befe5bce7..9d0ef0270ab 100644
--- a/api/src/org/labkey/api/settings/AppProps.java
+++ b/api/src/org/labkey/api/settings/AppProps.java
@@ -49,6 +49,7 @@ public interface AppProps
     String EXPERIMENTAL_RESOLVE_PROPERTY_URI_COLUMNS = "resolve-property-uri-columns";
     String DEPRECATED_OBJECT_LEVEL_DISCUSSIONS = "deprecatedObjectLevelDiscussions";
     String ADMIN_PROVIDED_ALLOWED_EXTERNAL_RESOURCES = "allowedExternalResources";
+    String QUANTITY_COLUMN_SUFFIX_TESTING = "quantityColumnSuffixTesting";
 
     String UNKNOWN_VERSION = "Unknown Release Version";
 
diff --git a/experiment/src/org/labkey/experiment/ExperimentModule.java b/experiment/src/org/labkey/experiment/ExperimentModule.java
index dd46628e45c..e5b397c11cc 100644
--- a/experiment/src/org/labkey/experiment/ExperimentModule.java
+++ b/experiment/src/org/labkey/experiment/ExperimentModule.java
@@ -255,8 +255,9 @@ protected void init()
         {
             OptionalFeatureService.get().addExperimentalFeatureFlag(NameGenerator.EXPERIMENTAL_ALLOW_GAP_COUNTER, "Allow gap with withCounter and rootSampleCount expression",
                 "Check this option if gaps in the count generated by withCounter or rootSampleCount name expression are allowed.", true);
-
         }
+        OptionalFeatureService.get().addExperimentalFeatureFlag(AppProps.QUANTITY_COLUMN_SUFFIX_TESTING, "Quantity column suffix testing",
+                "If a column name contains a \"__<unit>\" suffix, this feature allows for testing it as a Quantity display column", false);
 
         RoleManager.registerPermission(new DesignVocabularyPermission(), true);
         RoleManager.registerRole(new SampleTypeDesignerRole());

From 7f1e3df2857810df99b196f4449889a33cc7ef31 Mon Sep 17 00:00:00 2001
From: labkey-susanh <susanh@labkey.com>
Date: Thu, 14 Aug 2025 06:40:46 -0700
Subject: [PATCH 11/18] Add "unit" unit to reflect current usage and some minor
 helper methods

---
 api/src/org/labkey/api/ontology/Unit.java | 20 +++++++++++++++++++-
 1 file changed, 19 insertions(+), 1 deletion(-)

diff --git a/api/src/org/labkey/api/ontology/Unit.java b/api/src/org/labkey/api/ontology/Unit.java
index b741e7d4fb9..79a2051a1a3 100644
--- a/api/src/org/labkey/api/ontology/Unit.java
+++ b/api/src/org/labkey/api/ontology/Unit.java
@@ -1,6 +1,7 @@
 package org.labkey.api.ontology;
 
 import lombok.Getter;
+import org.apache.commons.lang3.StringUtils;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.HashMap;
@@ -16,6 +17,10 @@ public enum Unit
             Quantity.class,
             "count", "count"),
 
+    unit(KindOfQuantity.Count, null, 1.0, "",
+            Quantity.class,
+            "unit", "units"),
+
     // UCUM prefers "l", but "L" is also common and already supported by inventory (sorry Lambert)
     l(KindOfQuantity.Volume, null, 10e0, "l",
             Quantity.Volume_l.class,
@@ -74,6 +79,7 @@ public enum Unit
 
     @Getter
     final @NotNull KindOfQuantity kindOfQuantity;
+    @Getter
     final @NotNull Unit base;
     final @NotNull String print;
     // this is not a 'real' class, but is used for ConvertHelper binding
@@ -98,6 +104,16 @@ public enum Unit
         this.otherNames = null==otherNames || otherNames.length==0 ? null : otherNames;
     }
 
+    public boolean isBase()
+    {
+        return this == base;
+    }
+
+    public boolean isCompatible(Unit other)
+    {
+        return other.base == base;
+    }
+
     public double toBaseUnitValue(double v)
     {
         return v * this.value;
@@ -145,6 +161,8 @@ public String toString()
 
     public static Unit fromName(String unitName)
     {
+        if (StringUtils.isEmpty(unitName))
+            return null;
         Unit unit = unitMap.get(unitName);
         if (null == unit)
             unit = unitMap.get(unitName.toLowerCase());
@@ -161,7 +179,7 @@ static Function<Double,Double> convertFn(Unit from, Unit to)
         return (x) -> to.fromBaseUnitValue(from.toBaseUnitValue(x));
     }
 
-    static double convert(double value, Unit from, Unit to)
+    public static double convert(double value, Unit from, Unit to)
     {
         if (from.base != to.base)
             throw new IllegalArgumentException("Can't convert " + from.name() + " to " + to.name());

From c28adfb7ca805e303dc567cfc77357ff2b9bd943 Mon Sep 17 00:00:00 2001
From: cnathe <cnathe@labkey.com>
Date: Thu, 14 Aug 2025 09:20:01 -0500
Subject: [PATCH 12/18] Quantity.java unit tests

---
 api/src/org/labkey/api/ontology/Quantity.java | 100 +++++++++++++++---
 .../labkey/experiment/ExperimentModule.java   |   4 +-
 2 files changed, 87 insertions(+), 17 deletions(-)

diff --git a/api/src/org/labkey/api/ontology/Quantity.java b/api/src/org/labkey/api/ontology/Quantity.java
index 3aca9673ce2..434c6d8f491 100644
--- a/api/src/org/labkey/api/ontology/Quantity.java
+++ b/api/src/org/labkey/api/ontology/Quantity.java
@@ -12,8 +12,6 @@
 import java.text.Format;
 import java.util.regex.Pattern;
 
-import static org.labkey.api.ontology.Unit.g;
-
 /* CONSIDER: it's tempting to store BigDecimal in memory after parse for math/conversion purposed, even if we store as double in the database */
 
 /*
@@ -128,7 +126,7 @@ public String format()
 
     public String format(Unit unit)
     {
-        return unit.fromStorageUnitValue(value) + unit.print;
+        return value(unit) + unit.print;
     }
 
     public String format(Format format)
@@ -138,7 +136,7 @@ public String format(Format format)
 
     public String format(Unit unit, Format format)
     {
-        return format.format(unit.fromStorageUnitValue(value)) + unit.print;
+        return format.format(value(unit)) + unit.print;
     }
 
     /**
@@ -235,8 +233,8 @@ private static Quantity parse(@NotNull String s, @NotNull Unit defaultUnit) thro
         String unitPart=null;
         if (split > 0)
         {
-            valuePart = s.substring(0, split);
-            unitPart = s.substring(split+1);
+            valuePart = s.substring(0, split).trim();
+            unitPart = s.substring(split+1).trim();
         }
         else
         {
@@ -264,7 +262,7 @@ private static Quantity parse(@NotNull String s, @NotNull Unit defaultUnit) thro
                     new BigDecimal(valuePart);
             var unit = StringUtils.isBlank(unitPart) ? defaultUnit : Unit.fromName(unitPart);
             if (null == unit)
-                unit = Unit.no_unit;
+                throw new ConversionException("Could not parse unit: " + unitPart);
             if (defaultUnit!=Unit.no_unit && !defaultUnit.kindOfQuantity.accept(unit))
                 throw new ConversionException("Quantity is of wrong type: expected " + defaultUnit.kindOfQuantity.getName() + " found " + unit);
             return Quantity.of(value, unit);
@@ -375,16 +373,48 @@ void failToParse(String s, Unit defaultUnit)
         @Test
         public void testParse()
         {
-            assertEquals(Quantity.of(1,g), parse("1", g));
-            assertEquals(Quantity.of(1,g), parse("1g"));
-            assertEquals(Quantity.of(1,g), parse("0.001kg"));
+            assertEquals(Quantity.of(1, Unit.g), parse("1", Unit.g));
+            assertEquals(Quantity.of(1, Unit.g), parse("1g"));
+            assertEquals(Quantity.of(1, Unit.g), parse("0.001kg"));
+
+            assertEquals(Quantity.of(1, Unit.count), parse("1"));
+            assertEquals(Quantity.of(1, Unit.count), parse("1 unit"));
+            assertEquals(Quantity.of(0, Unit.count), parse("0 no units"));
+            assertEquals(Quantity.of(0, Unit.count), parse("0count"));
+
             assertEquals(parse("1000mg"), parse("0.001kg"));
+            assertEquals(parse(" 1000mg"), parse("0.001kg"));
+            assertEquals(parse("1000mg "), parse("0.001kg"));
+            assertEquals(parse("1000 mg"), parse("0.001kg"));
+            assertEquals(parse("1000  mg"), parse("0.001kg"));
+        }
 
+        @Test
+        public void testFailToParseNoDigit()
+        {
             failToParse("kg");
+            failToParse("test");
+            failToParse("+");
+            failToParse(".");
+            failToParse("-");
+            failToParse("+e1");
+        }
+
+        @Test
+        public void testFailToParseInvalidUnit()
+        {
             failToParse("124xyz");
+            failToParse("124 xyz");
             failToParse("g100");
+        }
 
+        @Test
+        public void testFailToParseCantConvert()
+        {
             failToParse("1g", Unit.l);
+            failToParse("1g", Unit.ml);
+            failToParse("1g", Unit.count);
+            failToParse("1g", Unit.unit);
         }
 
         @Test
@@ -405,10 +435,10 @@ public void testPattern()
             assertTrue(pattern.matcher("-.2").matches());
 
             // no digits
-            assertFalse(pattern.matcher("+").matches());
-            assertFalse(pattern.matcher(".").matches());
-            assertFalse(pattern.matcher("-").matches());
-            assertFalse(pattern.matcher("+e1").matches());
+            assertTrue(pattern.matcher("+").matches());
+            assertTrue(pattern.matcher(".").matches());
+            assertTrue(pattern.matcher("-").matches());
+            assertTrue(pattern.matcher("+e1").matches());
 
             //exponents
             assertEquals(0.1e2, Double.valueOf(".1e2"), 0.0);
@@ -421,6 +451,9 @@ public void testPattern()
             // units
             assertTrue(pattern.matcher("1.23μF").matches());
             assertTrue(pattern.matcher("1.2e3 mℓ").matches());
+            assertTrue(pattern.matcher("test").matches());
+            assertTrue(pattern.matcher("g").matches());
+            assertTrue(pattern.matcher("mℓ").matches());
         }
 
 
@@ -431,12 +464,47 @@ public void testConversion()
             registerQuantityConverters();
 
             q = (Quantity)ConvertUtils.convert("1.234kg", Quantity.Mass_g.class);
-            assertEquals(q.getClass(), Quantity.class);
+            assertEquals(Quantity.class, q.getClass());
             assertEquals(new Quantity(KindOfQuantity.Mass, 1234d), q);
 
             q = (Quantity)ConvertUtils.convert("1234", Quantity.Mass_g.class);
-            assertEquals(q.getClass(), Quantity.class);
+            assertEquals(Quantity.class, q.getClass());
             assertEquals(new Quantity(KindOfQuantity.Mass, 1234d), q);
+
+            q = (Quantity)ConvertUtils.convert("1234", Quantity.Mass_kg.class);
+            assertEquals(Quantity.class, q.getClass());
+            assertEquals(new Quantity(KindOfQuantity.Mass, 1234000d), q);
+
+            q = (Quantity)ConvertUtils.convert("1234", Quantity.Mass_ug.class);
+            assertEquals(Quantity.class, q.getClass());
+            assertEquals(new Quantity(KindOfQuantity.Mass, 0.001234d), q);
+        }
+
+        @Test
+        public void testDoubleValue()
+        {
+            Quantity q = Quantity.of(1, Unit.g);
+            assertEquals(1.0, q.doubleValue(Unit.g), 0.0);
+            assertEquals(0.001, q.doubleValue(Unit.kg), 0.0);
+            assertEquals(1000.0, q.doubleValue(Unit.mg), 0.001);
+            assertEquals(1000000.0, q.doubleValue(Unit.ug), 0.001);
+            assertEquals(1000000000.0, q.doubleValue(Unit.ng), 0.001);
+        }
+
+        @Test
+        public void testFormat()
+        {
+            Quantity q = Quantity.of(1, Unit.g);
+            assertEquals("1.0g", q.format());
+            assertEquals("1.0g", q.format(Unit.g));
+            assertEquals("0.001kg", q.format(Unit.kg));
+            assertEquals("1000.0mg", q.format(Unit.mg));
+
+            // with format
+            Format f = new java.text.DecimalFormat("#.###");
+            assertEquals("1.000g", q.format(f));
+            assertEquals("1.000g", q.format(Unit.g, f));
+            assertEquals("0.001kg", q.format(Unit.kg, f));
         }
     }
 }
diff --git a/experiment/src/org/labkey/experiment/ExperimentModule.java b/experiment/src/org/labkey/experiment/ExperimentModule.java
index e4bf08724c7..526181b51c8 100644
--- a/experiment/src/org/labkey/experiment/ExperimentModule.java
+++ b/experiment/src/org/labkey/experiment/ExperimentModule.java
@@ -79,6 +79,7 @@
 import org.labkey.api.module.SpringModule;
 import org.labkey.api.module.Summary;
 import org.labkey.api.ontology.OntologyService;
+import org.labkey.api.ontology.Quantity;
 import org.labkey.api.pipeline.PipelineService;
 import org.labkey.api.query.FilteredTable;
 import org.labkey.api.query.QueryService;
@@ -1031,7 +1032,8 @@ public Set<Class> getUnitTests()
             LSIDRelativizer.TestCase.class,
             Lsid.TestCase.class,
             LsidUtils.TestCase.class,
-            PropertyController.TestCase.class
+            PropertyController.TestCase.class,
+            Quantity.TestCase.class
         );
     }
 

From ae9d24488716576d6ac6dea1413fbeb601c4a838 Mon Sep 17 00:00:00 2001
From: cnathe <cnathe@labkey.com>
Date: Thu, 14 Aug 2025 09:21:55 -0500
Subject: [PATCH 13/18] Set Unit enum base to "unit" and "ml"

---
 .../org/labkey/api/data/DisplayColumn.java    |  2 +-
 .../labkey/api/ontology/KindOfQuantity.java   |  4 +--
 api/src/org/labkey/api/ontology/Unit.java     | 32 +++++++++----------
 3 files changed, 18 insertions(+), 20 deletions(-)

diff --git a/api/src/org/labkey/api/data/DisplayColumn.java b/api/src/org/labkey/api/data/DisplayColumn.java
index bbf24e76ec5..2ec22992cb2 100644
--- a/api/src/org/labkey/api/data/DisplayColumn.java
+++ b/api/src/org/labkey/api/data/DisplayColumn.java
@@ -537,7 +537,7 @@ protected final String formatValue(RenderContext ctx, final Object value, String
             if (null == format)
                 formattedString = q.format(displayUnit);
             else
-                formattedString = q.format(displayUnit, format);\
+                formattedString = q.format(displayUnit, format);
              */
             /* DISPLAY WITHOUT UNIT SUFFIX */
             var doubleValue = q.doubleValue(displayUnit);
diff --git a/api/src/org/labkey/api/ontology/KindOfQuantity.java b/api/src/org/labkey/api/ontology/KindOfQuantity.java
index 399abef92ff..bca8a8b902c 100644
--- a/api/src/org/labkey/api/ontology/KindOfQuantity.java
+++ b/api/src/org/labkey/api/ontology/KindOfQuantity.java
@@ -33,12 +33,12 @@ List<Unit> getCommonUnits()
     },
 
     // Not a real unit per UCUM, but useful for annotation of "storage amount" for instance.
-    Count("", "no_unit")
+    Count("", "unit")
     {
         @Override
         List<Unit> getCommonUnits()
         {
-            return List.of(Unit.count);
+            return List.of(Unit.count, Unit.no_unit, Unit.unit);
         }
     };
 
diff --git a/api/src/org/labkey/api/ontology/Unit.java b/api/src/org/labkey/api/ontology/Unit.java
index 79a2051a1a3..4e2d9900d19 100644
--- a/api/src/org/labkey/api/ontology/Unit.java
+++ b/api/src/org/labkey/api/ontology/Unit.java
@@ -9,45 +9,43 @@
 
 public enum Unit
 {
-    no_unit(KindOfQuantity.Count, null, 1.0, "",
+    unit(KindOfQuantity.Count, null, 1.0, "",
             Quantity.class,
-            "no units", "no units"),
-
-    count(KindOfQuantity.Count, null, 1.0, "",
+            "unit", "units"),
+    count(KindOfQuantity.Count, unit, 1.0, "",
             Quantity.class,
             "count", "count"),
-
-    unit(KindOfQuantity.Count, null, 1.0, "",
+    no_unit(KindOfQuantity.Count, unit, 1.0, "",
             Quantity.class,
-            "unit", "units"),
+            "no units", "no units"),
 
+    ml(KindOfQuantity.Volume, null, 10e-3, "ml",
+            Quantity.Volume_ml.class,
+            "milliliter", "milliliters",
+            "mL", "millilitre", "millilitres"),
     // UCUM prefers "l", but "L" is also common and already supported by inventory (sorry Lambert)
-    l(KindOfQuantity.Volume, null, 10e0, "l",
+    l(KindOfQuantity.Volume, ml, 10e0, "l",
             Quantity.Volume_l.class,
             "liter", "liters",
             "L", "ℓ", "litre", "liters"),
     // is it better to include these little used units, to avoid future case-sensitivity problems?
-    Ml(KindOfQuantity.Volume, l, 10e3, "Ml",
+    Ml(KindOfQuantity.Volume, ml, 10e3, "Ml",
             Quantity.Volume_Megal.class,
             "megaliter", "megaliters",
             "ML", "megalitre", "megalitres"),
-    kl(KindOfQuantity.Volume, l, 10e3, "kl",
+    kl(KindOfQuantity.Volume, ml, 10e3, "kl",
             Quantity.Volume_kl.class,
             "kiloliter", "kiloliters",
             "kL", "kilolitre", "kilolitres"),
-    ml(KindOfQuantity.Volume, l, 10e-3, "ml",
-            Quantity.Volume_ml.class,
-            "milliliter", "milliliters",
-            "mL", "millilitre", "millilitres"),
-    ul(KindOfQuantity.Volume, l, 10e-6, "ul",
+    ul(KindOfQuantity.Volume, ml, 10e-6, "ul",
             Quantity.Volume_ul.class,
             "microliter", "microliters",
             "uL", "μl", "μL", "microlitre", "microlitres"),
-    nl(KindOfQuantity.Volume, l, 10e-9, "nl",
+    nl(KindOfQuantity.Volume, ml, 10e-9, "nl",
             Quantity.Volume_nl.class,
             "nanoliter", "nanoliters",
             "nL", "nanolitre", "nanolitres"),
-    pl(KindOfQuantity.Volume, l, 10e-12, "pl",
+    pl(KindOfQuantity.Volume, ml, 10e-12, "pl",
             Quantity.Volume_pl.class,
             "picoliter", "picoliters",
             "pL", "picolitre", "picolitres"),

From 8f2d333c0aa95bee39146344ade9bf817e52eb02 Mon Sep 17 00:00:00 2001
From: cnathe <cnathe@labkey.com>
Date: Thu, 14 Aug 2025 09:41:36 -0500
Subject: [PATCH 14/18] fixup Quantity testFormat test case

---
 api/src/org/labkey/api/ontology/Quantity.java | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/api/src/org/labkey/api/ontology/Quantity.java b/api/src/org/labkey/api/ontology/Quantity.java
index 434c6d8f491..3b3346ad827 100644
--- a/api/src/org/labkey/api/ontology/Quantity.java
+++ b/api/src/org/labkey/api/ontology/Quantity.java
@@ -7,6 +7,7 @@
 import org.jetbrains.annotations.NotNull;
 import org.junit.Assert;
 import org.junit.Test;
+import org.labkey.api.util.Formats;
 
 import java.math.BigDecimal;
 import java.text.Format;
@@ -501,10 +502,10 @@ public void testFormat()
             assertEquals("1000.0mg", q.format(Unit.mg));
 
             // with format
-            Format f = new java.text.DecimalFormat("#.###");
-            assertEquals("1.000g", q.format(f));
-            assertEquals("1.000g", q.format(Unit.g, f));
-            assertEquals("0.001kg", q.format(Unit.kg, f));
+            assertEquals("1.000g", q.format(Formats.f3));
+            assertEquals("1.000g", q.format(Unit.g, Formats.f3));
+            assertEquals("0.001kg", q.format(Unit.kg, Formats.f3));
+            assertEquals("1000000ug", q.format(Unit.ug, Formats.fv3));
         }
     }
 }

From dbe0f432a963d7c65158fdaa16be0a2dec06c6fe Mon Sep 17 00:00:00 2001
From: cnathe <cnathe@labkey.com>
Date: Thu, 14 Aug 2025 10:36:38 -0500
Subject: [PATCH 15/18] Unit.java unit tests and set ml base unit value as 1
 instead of liter

---
 api/src/org/labkey/api/ontology/Quantity.java |   4 -
 api/src/org/labkey/api/ontology/Unit.java     | 130 ++++++++++++++++--
 .../labkey/experiment/ExperimentModule.java   |   4 +-
 3 files changed, 119 insertions(+), 19 deletions(-)

diff --git a/api/src/org/labkey/api/ontology/Quantity.java b/api/src/org/labkey/api/ontology/Quantity.java
index 3b3346ad827..c340e748610 100644
--- a/api/src/org/labkey/api/ontology/Quantity.java
+++ b/api/src/org/labkey/api/ontology/Quantity.java
@@ -475,10 +475,6 @@ public void testConversion()
             q = (Quantity)ConvertUtils.convert("1234", Quantity.Mass_kg.class);
             assertEquals(Quantity.class, q.getClass());
             assertEquals(new Quantity(KindOfQuantity.Mass, 1234000d), q);
-
-            q = (Quantity)ConvertUtils.convert("1234", Quantity.Mass_ug.class);
-            assertEquals(Quantity.class, q.getClass());
-            assertEquals(new Quantity(KindOfQuantity.Mass, 0.001234d), q);
         }
 
         @Test
diff --git a/api/src/org/labkey/api/ontology/Unit.java b/api/src/org/labkey/api/ontology/Unit.java
index 4e2d9900d19..92638e7188a 100644
--- a/api/src/org/labkey/api/ontology/Unit.java
+++ b/api/src/org/labkey/api/ontology/Unit.java
@@ -3,6 +3,8 @@
 import lombok.Getter;
 import org.apache.commons.lang3.StringUtils;
 import org.jetbrains.annotations.NotNull;
+import org.junit.Assert;
+import org.junit.Test;
 
 import java.util.HashMap;
 import java.util.function.Function;
@@ -19,58 +21,58 @@ public enum Unit
             Quantity.class,
             "no units", "no units"),
 
-    ml(KindOfQuantity.Volume, null, 10e-3, "ml",
+    ml(KindOfQuantity.Volume, null, 1e0, "ml",
             Quantity.Volume_ml.class,
             "milliliter", "milliliters",
             "mL", "millilitre", "millilitres"),
     // UCUM prefers "l", but "L" is also common and already supported by inventory (sorry Lambert)
-    l(KindOfQuantity.Volume, ml, 10e0, "l",
+    l(KindOfQuantity.Volume, ml, 1e3, "l",
             Quantity.Volume_l.class,
             "liter", "liters",
             "L", "ℓ", "litre", "liters"),
     // is it better to include these little used units, to avoid future case-sensitivity problems?
-    Ml(KindOfQuantity.Volume, ml, 10e3, "Ml",
+    Ml(KindOfQuantity.Volume, ml, 1e9, "Ml",
             Quantity.Volume_Megal.class,
             "megaliter", "megaliters",
             "ML", "megalitre", "megalitres"),
-    kl(KindOfQuantity.Volume, ml, 10e3, "kl",
+    kl(KindOfQuantity.Volume, ml, 1e6, "kl",
             Quantity.Volume_kl.class,
             "kiloliter", "kiloliters",
             "kL", "kilolitre", "kilolitres"),
-    ul(KindOfQuantity.Volume, ml, 10e-6, "ul",
+    ul(KindOfQuantity.Volume, ml, 1e-3, "ul",
             Quantity.Volume_ul.class,
             "microliter", "microliters",
             "uL", "μl", "μL", "microlitre", "microlitres"),
-    nl(KindOfQuantity.Volume, ml, 10e-9, "nl",
+    nl(KindOfQuantity.Volume, ml, 1e-6, "nl",
             Quantity.Volume_nl.class,
             "nanoliter", "nanoliters",
             "nL", "nanolitre", "nanolitres"),
-    pl(KindOfQuantity.Volume, ml, 10e-12, "pl",
+    pl(KindOfQuantity.Volume, ml, 1e-9, "pl",
             Quantity.Volume_pl.class,
             "picoliter", "picoliters",
             "pL", "picolitre", "picolitres"),
 
-    g(KindOfQuantity.Mass, null, 10e0, "g",
+    g(KindOfQuantity.Mass, null, 1e0, "g",
             Quantity.Mass_g.class,
             "gram", "grams"),
-    Mg(KindOfQuantity.Mass, g, 10e6, "Mg",
+    Mg(KindOfQuantity.Mass, g, 1e6, "Mg",
             Quantity.Mass_Megag.class,
             "megagram", "megagrams",
             "tonne", "tonnes"),
-    kg(KindOfQuantity.Mass, g, 10e3, "kg",
+    kg(KindOfQuantity.Mass, g, 1e3, "kg",
             Quantity.Mass_kg.class,
             "kilogram", "kilograms"),
-    mg(KindOfQuantity.Mass, g, 10e-3, "mg",
+    mg(KindOfQuantity.Mass, g, 1e-3, "mg",
             Quantity.Mass_mg.class,
             "milligram", "milligrams"),
-    ug(KindOfQuantity.Mass, g, 10e-6, "ug",
+    ug(KindOfQuantity.Mass, g, 1e-6, "ug",
             Quantity.Mass_ug.class,
             "microgram", "micrograms",
         "μg"),
-    ng(KindOfQuantity.Mass, g, 10e-9, "ng",
+    ng(KindOfQuantity.Mass, g, 1e-9, "ng",
             Quantity.Mass_ng.class,
             "nanogram", "nanograms"),
-    pg(KindOfQuantity.Mass, g, 10e-12, "pg",
+    pg(KindOfQuantity.Mass, g, 1e-12, "pg",
             Quantity.Mass_pg.class,
             "picogram", "picograms");
 
@@ -188,4 +190,104 @@ public Quantity convert(Object value)
     {
         return Quantity.convert(value, this);
     }
+
+    public static class TestCase extends Assert
+    {
+        @Test
+        public void testIsBase()
+        {
+            assertTrue(Unit.ml.isBase());
+            assertFalse(Unit.l.isBase());
+            assertTrue(Unit.g.isBase());
+            assertFalse(Unit.kg.isBase());
+            assertTrue(Unit.unit.isBase());
+            assertFalse(Unit.count.isBase());
+        }
+
+        @Test
+        public void testIsCompatible()
+        {
+            assertTrue(Unit.ml.isCompatible(Unit.ul));
+            assertTrue(Unit.ml.isCompatible(Unit.l));
+            assertFalse(Unit.ml.isCompatible(Unit.g));
+            assertTrue(Unit.g.isCompatible(Unit.mg));
+            assertFalse(Unit.g.isCompatible(Unit.ml));
+            assertTrue(Unit.unit.isCompatible(Unit.count));
+            assertTrue(Unit.unit.isCompatible(Unit.no_unit));
+            assertFalse(Unit.unit.isCompatible(Unit.ml));
+        }
+
+        @Test
+        public void testBaseUnitValue()
+        {
+            assertEquals(1e0, Unit.ml.toBaseUnitValue(1.0), 0.00001);
+            assertEquals(1e3, Unit.l.toBaseUnitValue(1.0), 0.00001);
+            assertEquals(1e-3, Unit.ul.toBaseUnitValue(1.0), 0.00001);
+            assertEquals(1e0, Unit.g.toBaseUnitValue(1.0), 0.00001);
+            assertEquals(1e-3, Unit.mg.toBaseUnitValue(1.0), 0.00001);
+            assertEquals(1e-6, Unit.ug.toBaseUnitValue(1.0), 0.00001);
+            assertEquals(1e0, Unit.count.toBaseUnitValue(1.0), 0.00001);
+            assertEquals(1e0, Unit.no_unit.toBaseUnitValue(1.0), 0.00001);
+        }
+
+        @Test
+        public void testFromBaseUnitValue()
+        {
+            assertEquals(1.0, Unit.ml.fromBaseUnitValue(1e0), 0.00001);
+            assertEquals(1.0, Unit.l.fromBaseUnitValue(1e3), 0.00001);
+            assertEquals(1.0, Unit.ul.fromBaseUnitValue(1e-3), 0.00001);
+            assertEquals(1.0, Unit.g.fromBaseUnitValue(1e0), 0.00001);
+            assertEquals(1.0, Unit.mg.fromBaseUnitValue(1e-3), 0.00001);
+            assertEquals(1.0, Unit.ug.fromBaseUnitValue(1e-6), 0.00001);
+            assertEquals(1.0, Unit.count.fromBaseUnitValue(1e0), 0.00001);
+            assertEquals(1.0, Unit.no_unit.fromBaseUnitValue(1e0), 0.00001);
+        }
+
+        @Test
+        public void testToStorageUnitValue()
+        {
+            assertEquals(1.0, Unit.ml.toStorageUnitValue(1.0).doubleValue(), 0.00001);
+            assertEquals(1000.0, Unit.l.toStorageUnitValue(1.0).doubleValue(), 0.00001);
+            assertEquals(0.001, Unit.ul.toStorageUnitValue(1.0).doubleValue(), 0.00001);
+            assertEquals(1.0, Unit.g.toStorageUnitValue(1.0).doubleValue(), 0.00001);
+            assertEquals(0.001, Unit.mg.toStorageUnitValue(1.0).doubleValue(), 0.00001);
+            assertEquals(0.000001, Unit.ug.toStorageUnitValue(1.0).doubleValue(), 0.00001);
+            assertEquals(1.0, Unit.count.toStorageUnitValue(1.0).doubleValue(), 0.00001);
+            assertEquals(1.0, Unit.no_unit.toStorageUnitValue(1.0).doubleValue(), 0.00001);
+        }
+
+        @Test
+        public void testFromStorageUnitValue()
+        {
+            assertEquals(1.0, Unit.ml.fromStorageUnitValue(1.0).doubleValue(), 0.00001);
+            assertEquals(0.001, Unit.l.fromStorageUnitValue(1.0).doubleValue(), 0.00001);
+            assertEquals(1000.0, Unit.ul.fromStorageUnitValue(1.0).doubleValue(), 0.00001);
+            assertEquals(1.0, Unit.g.fromStorageUnitValue(1.0).doubleValue(), 0.00001);
+            assertEquals(1000.0, Unit.mg.fromStorageUnitValue(1.0).doubleValue(), 0.00001);
+            assertEquals(1000000.0, Unit.ug.fromStorageUnitValue(1.0).doubleValue(), 0.00001);
+            assertEquals(1.0, Unit.count.fromStorageUnitValue(1.0).doubleValue(), 0.00001);
+            assertEquals(1.0, Unit.no_unit.fromStorageUnitValue(1.0).doubleValue(), 0.00001);
+        }
+
+        @Test
+        public void testFromName()
+        {
+            assertEquals(Unit.ml, Unit.fromName("ml"));
+            assertEquals(Unit.ml, Unit.fromName("mL"));
+            assertEquals(Unit.ml, Unit.fromName("milliliter"));
+            assertEquals(Unit.ml, Unit.fromName("milliliters"));
+            assertEquals(Unit.ml, Unit.fromName("millilitre"));
+            assertEquals(Unit.ml, Unit.fromName("millilitres"));
+
+            assertEquals(Unit.l, Unit.fromName("l"));
+            assertEquals(Unit.l, Unit.fromName("L"));
+            assertEquals(Unit.l, Unit.fromName("liter"));
+            assertEquals(Unit.l, Unit.fromName("liters"));
+            assertEquals(Unit.l, Unit.fromName("litre"));
+            assertEquals(Unit.l, Unit.fromName("liters"));
+
+            assertNull(Unit.fromName(null));
+            assertNull(Unit.fromName(""));
+        }
+    }
 }
diff --git a/experiment/src/org/labkey/experiment/ExperimentModule.java b/experiment/src/org/labkey/experiment/ExperimentModule.java
index 526181b51c8..eaec7a20816 100644
--- a/experiment/src/org/labkey/experiment/ExperimentModule.java
+++ b/experiment/src/org/labkey/experiment/ExperimentModule.java
@@ -80,6 +80,7 @@
 import org.labkey.api.module.Summary;
 import org.labkey.api.ontology.OntologyService;
 import org.labkey.api.ontology.Quantity;
+import org.labkey.api.ontology.Unit;
 import org.labkey.api.pipeline.PipelineService;
 import org.labkey.api.query.FilteredTable;
 import org.labkey.api.query.QueryService;
@@ -1033,7 +1034,8 @@ public Set<Class> getUnitTests()
             Lsid.TestCase.class,
             LsidUtils.TestCase.class,
             PropertyController.TestCase.class,
-            Quantity.TestCase.class
+            Quantity.TestCase.class,
+            Unit.TestCase.class
         );
     }
 

From e9cf18d33ecb3e463b5902d04415992b380ce8fd Mon Sep 17 00:00:00 2001
From: cnathe <cnathe@labkey.com>
Date: Thu, 14 Aug 2025 15:27:28 -0500
Subject: [PATCH 16/18] CR feedback

---
 .../labkey/api/data/ColumnRenderPropertiesImpl.java    | 10 +++++++---
 api/src/org/labkey/api/data/DataColumn.java            |  2 +-
 api/src/org/labkey/api/data/DisplayColumn.java         |  4 +---
 3 files changed, 9 insertions(+), 7 deletions(-)

diff --git a/api/src/org/labkey/api/data/ColumnRenderPropertiesImpl.java b/api/src/org/labkey/api/data/ColumnRenderPropertiesImpl.java
index ada1ed96843..85d452d90a6 100644
--- a/api/src/org/labkey/api/data/ColumnRenderPropertiesImpl.java
+++ b/api/src/org/labkey/api/data/ColumnRenderPropertiesImpl.java
@@ -799,9 +799,13 @@ public Class<?> getJavaClass(boolean isNullable)
             ret = getJdbcType().getJavaClass(isNullable);
             isNumeric = getJdbcType().isNumeric();
         }
-        Unit unit = getDisplayUnit();
-        if (isNumeric && null != unit)
-           return unit.getQuantityClass();
+
+        if (isNumeric)
+        {
+            Unit unit = getDisplayUnit();
+            if (null != unit)
+                return unit.getQuantityClass();
+        }
         return ret;
     }
 
diff --git a/api/src/org/labkey/api/data/DataColumn.java b/api/src/org/labkey/api/data/DataColumn.java
index ec6fa2a7250..e19c61ec6ef 100644
--- a/api/src/org/labkey/api/data/DataColumn.java
+++ b/api/src/org/labkey/api/data/DataColumn.java
@@ -949,7 +949,7 @@ public String getSortHandler(RenderContext ctx, Sort.SortDirection sort)
         if (_caption == null)
             return null;
         var title = _caption.eval(ctx);
-        if (null != _displayColumn && null != _displayColumn.getDisplayUnit())
+        if (null != _displayColumn && null != _displayColumn.getDisplayUnit() && !StringUtils.isEmpty(_displayColumn.getDisplayUnit().toString()))
             title += " (" + _displayColumn.getDisplayUnit() + ")";
         return title.isEmpty() ? HtmlString.NBSP : HtmlString.of(title);
     }
diff --git a/api/src/org/labkey/api/data/DisplayColumn.java b/api/src/org/labkey/api/data/DisplayColumn.java
index 2ec22992cb2..9a582246844 100644
--- a/api/src/org/labkey/api/data/DisplayColumn.java
+++ b/api/src/org/labkey/api/data/DisplayColumn.java
@@ -388,10 +388,8 @@ public void setTsvFormatString(String formatString)
         _tsvFormat = createFormat(formatString, tsvFormatSymbols);
     }
 
-    private Format createFormat(String formatString, @Nullable DecimalFormatSymbols dfs)
+    private Format createFormat(@Nullable String formatString, @Nullable DecimalFormatSymbols dfs)
     {
-        if (null == formatString)
-            return null;
         return createFormat(formatString, getDisplayValueClass(), dfs);
     }
 

From 1dfd993fa65f4a685392396beb1eb3d7f59ef155 Mon Sep 17 00:00:00 2001
From: cnathe <cnathe@labkey.com>
Date: Fri, 15 Aug 2025 09:01:34 -0500
Subject: [PATCH 17/18] remove no_unit from Unit enum

---
 .../labkey/api/ontology/KindOfQuantity.java   |  2 +-
 api/src/org/labkey/api/ontology/Quantity.java | 20 +++++++++----------
 api/src/org/labkey/api/ontology/Unit.java     |  8 --------
 3 files changed, 11 insertions(+), 19 deletions(-)

diff --git a/api/src/org/labkey/api/ontology/KindOfQuantity.java b/api/src/org/labkey/api/ontology/KindOfQuantity.java
index bca8a8b902c..3187026c2d5 100644
--- a/api/src/org/labkey/api/ontology/KindOfQuantity.java
+++ b/api/src/org/labkey/api/ontology/KindOfQuantity.java
@@ -38,7 +38,7 @@ List<Unit> getCommonUnits()
         @Override
         List<Unit> getCommonUnits()
         {
-            return List.of(Unit.count, Unit.no_unit, Unit.unit);
+            return List.of(Unit.count, Unit.unit);
         }
     };
 
diff --git a/api/src/org/labkey/api/ontology/Quantity.java b/api/src/org/labkey/api/ontology/Quantity.java
index c340e748610..f68f87ddece 100644
--- a/api/src/org/labkey/api/ontology/Quantity.java
+++ b/api/src/org/labkey/api/ontology/Quantity.java
@@ -219,7 +219,7 @@ public double doubleValue()
 
     private static Quantity parse(@NotNull String s) throws ConversionException
     {
-        return parse(s, Unit.no_unit);
+        return parse(s, Unit.unit);
     }
 
 
@@ -264,7 +264,7 @@ private static Quantity parse(@NotNull String s, @NotNull Unit defaultUnit) thro
             var unit = StringUtils.isBlank(unitPart) ? defaultUnit : Unit.fromName(unitPart);
             if (null == unit)
                 throw new ConversionException("Could not parse unit: " + unitPart);
-            if (defaultUnit!=Unit.no_unit && !defaultUnit.kindOfQuantity.accept(unit))
+            if (!defaultUnit.kindOfQuantity.accept(unit))
                 throw new ConversionException("Quantity is of wrong type: expected " + defaultUnit.kindOfQuantity.getName() + " found " + unit);
             return Quantity.of(value, unit);
         }
@@ -375,19 +375,19 @@ void failToParse(String s, Unit defaultUnit)
         public void testParse()
         {
             assertEquals(Quantity.of(1, Unit.g), parse("1", Unit.g));
-            assertEquals(Quantity.of(1, Unit.g), parse("1g"));
-            assertEquals(Quantity.of(1, Unit.g), parse("0.001kg"));
+            assertEquals(Quantity.of(1, Unit.g), parse("1g", Unit.g));
+            assertEquals(Quantity.of(1, Unit.g), parse("0.001kg", Unit.g));
 
             assertEquals(Quantity.of(1, Unit.count), parse("1"));
             assertEquals(Quantity.of(1, Unit.count), parse("1 unit"));
-            assertEquals(Quantity.of(0, Unit.count), parse("0 no units"));
+            assertEquals(Quantity.of(0, Unit.count), parse("0 units"));
             assertEquals(Quantity.of(0, Unit.count), parse("0count"));
 
-            assertEquals(parse("1000mg"), parse("0.001kg"));
-            assertEquals(parse(" 1000mg"), parse("0.001kg"));
-            assertEquals(parse("1000mg "), parse("0.001kg"));
-            assertEquals(parse("1000 mg"), parse("0.001kg"));
-            assertEquals(parse("1000  mg"), parse("0.001kg"));
+            assertEquals(parse("1000mg", Unit.g), parse("0.001kg", Unit.g));
+            assertEquals(parse(" 1000mg", Unit.g), parse("0.001kg", Unit.g));
+            assertEquals(parse("1000mg ", Unit.g), parse("0.001kg", Unit.g));
+            assertEquals(parse("1000 mg", Unit.g), parse("0.001kg", Unit.g));
+            assertEquals(parse("1000  mg", Unit.g), parse("0.001kg", Unit.g));
         }
 
         @Test
diff --git a/api/src/org/labkey/api/ontology/Unit.java b/api/src/org/labkey/api/ontology/Unit.java
index 92638e7188a..c8caaa05699 100644
--- a/api/src/org/labkey/api/ontology/Unit.java
+++ b/api/src/org/labkey/api/ontology/Unit.java
@@ -17,9 +17,6 @@ public enum Unit
     count(KindOfQuantity.Count, unit, 1.0, "",
             Quantity.class,
             "count", "count"),
-    no_unit(KindOfQuantity.Count, unit, 1.0, "",
-            Quantity.class,
-            "no units", "no units"),
 
     ml(KindOfQuantity.Volume, null, 1e0, "ml",
             Quantity.Volume_ml.class,
@@ -213,7 +210,6 @@ public void testIsCompatible()
             assertTrue(Unit.g.isCompatible(Unit.mg));
             assertFalse(Unit.g.isCompatible(Unit.ml));
             assertTrue(Unit.unit.isCompatible(Unit.count));
-            assertTrue(Unit.unit.isCompatible(Unit.no_unit));
             assertFalse(Unit.unit.isCompatible(Unit.ml));
         }
 
@@ -227,7 +223,6 @@ public void testBaseUnitValue()
             assertEquals(1e-3, Unit.mg.toBaseUnitValue(1.0), 0.00001);
             assertEquals(1e-6, Unit.ug.toBaseUnitValue(1.0), 0.00001);
             assertEquals(1e0, Unit.count.toBaseUnitValue(1.0), 0.00001);
-            assertEquals(1e0, Unit.no_unit.toBaseUnitValue(1.0), 0.00001);
         }
 
         @Test
@@ -240,7 +235,6 @@ public void testFromBaseUnitValue()
             assertEquals(1.0, Unit.mg.fromBaseUnitValue(1e-3), 0.00001);
             assertEquals(1.0, Unit.ug.fromBaseUnitValue(1e-6), 0.00001);
             assertEquals(1.0, Unit.count.fromBaseUnitValue(1e0), 0.00001);
-            assertEquals(1.0, Unit.no_unit.fromBaseUnitValue(1e0), 0.00001);
         }
 
         @Test
@@ -253,7 +247,6 @@ public void testToStorageUnitValue()
             assertEquals(0.001, Unit.mg.toStorageUnitValue(1.0).doubleValue(), 0.00001);
             assertEquals(0.000001, Unit.ug.toStorageUnitValue(1.0).doubleValue(), 0.00001);
             assertEquals(1.0, Unit.count.toStorageUnitValue(1.0).doubleValue(), 0.00001);
-            assertEquals(1.0, Unit.no_unit.toStorageUnitValue(1.0).doubleValue(), 0.00001);
         }
 
         @Test
@@ -266,7 +259,6 @@ public void testFromStorageUnitValue()
             assertEquals(1000.0, Unit.mg.fromStorageUnitValue(1.0).doubleValue(), 0.00001);
             assertEquals(1000000.0, Unit.ug.fromStorageUnitValue(1.0).doubleValue(), 0.00001);
             assertEquals(1.0, Unit.count.fromStorageUnitValue(1.0).doubleValue(), 0.00001);
-            assertEquals(1.0, Unit.no_unit.fromStorageUnitValue(1.0).doubleValue(), 0.00001);
         }
 
         @Test

From 9c5c41f0ca7a909366e7f2cb31ea2abdf748d4fa Mon Sep 17 00:00:00 2001
From: cnathe <cnathe@labkey.com>
Date: Mon, 18 Aug 2025 15:01:49 -0500
Subject: [PATCH 18/18] update QNode unit test type

---
 query/src/org/labkey/query/sql/QNode.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/query/src/org/labkey/query/sql/QNode.java b/query/src/org/labkey/query/sql/QNode.java
index d9af20d205b..4e61134765f 100644
--- a/query/src/org/labkey/query/sql/QNode.java
+++ b/query/src/org/labkey/query/sql/QNode.java
@@ -472,7 +472,7 @@ public void testType()
             test("CONVERT(now(),SQL_DATE)", JdbcType.DATE);
             test("CAST(now() AS DATE)", JdbcType.DATE);
             test("CASE WHEN 1=1 THEN CONVERT(now(),SQL_DATE) ELSE CAST(now() AS DATE) END", JdbcType.DATE);
-            test("1 + 2.0", JdbcType.DOUBLE);
+            test("1 + 2.0", JdbcType.DECIMAL);
             test("'hello' | 'world'", JdbcType.VARCHAR);
         }