Misc cleanup of errors and docs

partiql-ast/src/main/java/org/partiql/ast/DataType.java

@@ -38,7 +38,7 @@ public static class StructField extends AstNode {
 
         private final boolean optional;
 
-        @Nullable
+        @NotNull
         private final List<AttributeConstraint> constraints;
 
         @Nullable
@@ -48,7 +48,7 @@ public StructField(
                 @NotNull Identifier.Simple name,
                 @NotNull DataType type,
                 boolean optional,
-                @Nullable List<AttributeConstraint> constraints,
+                @NotNull List<AttributeConstraint> constraints,
                 @Nullable String comment) {
             this.name = name;
             this.type = type;
@@ -86,7 +86,7 @@ public boolean isOptional() {
             return this.optional;
         }
 
-        @Nullable
+        @NotNull
         public List<AttributeConstraint> getConstraints() {
             return this.constraints;
         }

partiql-cli/src/main/kotlin/org/partiql/cli/pipeline/ErrorMessageFormatter.kt

@@ -123,10 +123,10 @@ object ErrorMessageFormatter {
      */
     private fun divisionByZero(error: PError): String {
         val dividendType = error.getOrNull("DIVIDEND_TYPE", PType::class.java)
-        val dividendTypeStr = prepare(dividendType.toString(), " of ")
+        val dividendTypeStr = prepare(dividendType.toString(), " of type ")
         val dividend = error.getOrNull("DIVIDEND", String::class.java)
-        val dividendStr = prepare(dividend.toString(), " -- ", " / 0")
-        return "Division$dividendTypeStr by zero$dividendStr$dividendTypeStr."
+        val dividendStr = prepare(dividend.toString(), " ")
+        return "Cannot divide$dividendStr$dividendTypeStr by zero."
     }
 
     /**

partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rex/ExprCallDynamic.kt

@@ -158,13 +158,12 @@ internal class ExprCallDynamic(
      * This implementation assumes that the [eval] input values contains the original arguments for the desired [function].
      * It performs the coercions (if necessary) before computing the result.
      *
-     * TODO what about MISSING calls?
-     *
      * @see ExprCallDynamic
      */
     private class Candidate(private var function: Function.Instance) {
 
         private var nil = { Datum.nullValue(function.returns) }
+        private var missing = { Datum.missing(function.returns) }
 
         /**
          * Function instance parameters (just types).
@@ -175,6 +174,9 @@ internal class ExprCallDynamic(
                 if (function.isNullCall && arg.isNull) {
                     return nil.invoke()
                 }
+                if (function.isMissingCall && arg.isMissing) {
+                    return missing.invoke()
+                }
                 val argType = arg.type
                 val paramType = function.parameters[i]
                 when (paramType == argType) {

partiql-eval/src/test/kotlin/org/partiql/eval/internal/DataExceptionTest.kt

@@ -9,7 +9,6 @@ import org.junit.jupiter.params.provider.MethodSource
  * E2E evaluation tests that give a data exception.
  */
 class DataExceptionTest {
-
     @ParameterizedTest
     @MethodSource("plusOverflowTests")
     @Execution(ExecutionMode.CONCURRENT)
@@ -34,6 +33,10 @@ class DataExceptionTest {
     @MethodSource("divideByZeroTests")
     fun divideByZero(tc: FailureTestCase) = tc.run()
 
+    @ParameterizedTest
+    @MethodSource("modByZeroTests")
+    fun modByZero(tc: FailureTestCase) = tc.run()
+
     @ParameterizedTest
     @MethodSource("absOverflowTests")
     fun absOverflow(tc: FailureTestCase) = tc.run()
@@ -184,6 +187,58 @@ class DataExceptionTest {
             // BIGINT
             FailureTestCase(
                 input = "CAST(1 AS BIGINT) / CAST(0 AS BIGINT)"
+            ),
+            // DECIMAL
+            FailureTestCase(
+                input = "CAST(1.0 AS DECIMAL) / CAST(0.0 AS DECIMAL)"
+            ),
+            // NUMERIC
+            FailureTestCase(
+                input = "CAST(1.0 AS NUMERIC) / CAST(0.0 AS NUMERIC)"
+            ),
+            // FLOAT
+            FailureTestCase(
+                input = "CAST(1.0e0 AS FLOAT) / CAST(0.0 AS FLOAT)"
+            ),
+            // REAL
+            FailureTestCase(
+                input = "CAST(1.0e0 AS DOUBLE PRECISION) / CAST(0.0 AS DOUBLE PRECISION)"
+            )
+        )
+
+        @JvmStatic
+        fun modByZeroTests() = listOf(
+            // TINYINT
+            FailureTestCase(
+                input = "CAST(1 AS TINYINT) % CAST(0 AS TINYINT)"
+            ),
+            // SMALLINT
+            FailureTestCase(
+                input = "CAST(1 AS SMALLINT) % CAST(0 AS SMALLINT)"
+            ),
+            // INT
+            FailureTestCase(
+                input = "CAST(1 AS INT) % CAST(0 AS INT)"
+            ),
+            // BIGINT
+            FailureTestCase(
+                input = "CAST(1 AS BIGINT) % CAST(0 AS BIGINT)"
+            ),
+            // DECIMAL
+            FailureTestCase(
+                input = "CAST(1.0 AS DECIMAL) % CAST(0.0 AS DECIMAL)"
+            ),
+            // NUMERIC
+            FailureTestCase(
+                input = "CAST(1.0 AS NUMERIC) % CAST(0.0 AS NUMERIC)"
+            ),
+            // FLOAT
+            FailureTestCase(
+                input = "CAST(1.0e0 AS FLOAT) % CAST(0.0 AS FLOAT)"
+            ),
+            // REAL
+            FailureTestCase(
+                input = "CAST(1.0e0 AS DOUBLE PRECISION) % CAST(0.0 AS DOUBLE PRECISION)"
             )
         )
 

partiql-parser/src/main/kotlin/org/partiql/parser/internal/PartiQLParserDefault.kt

@@ -2044,7 +2044,13 @@ internal class PartiQLParserDefault : PartiQLParser {
                 GeneratedParser.INT8 -> DataType.INT8()
                 GeneratedParser.INTEGER8 -> DataType.INTEGER8()
                 GeneratedParser.FLOAT -> DataType.FLOAT()
-                GeneratedParser.DOUBLE -> TODO() // not sure if DOUBLE is to be supported
+                GeneratedParser.DOUBLE -> {
+                    if (ctx.stop.type == GeneratedParser.PRECISION) {
+                        DataType.DOUBLE_PRECISION()
+                    } else {
+                        throw error(ctx, "Unknown atomic type.")
+                    }
+                } // not sure if DOUBLE is to be supported
                 GeneratedParser.REAL -> DataType.REAL()
                 GeneratedParser.TIMESTAMP -> DataType.TIMESTAMP()
                 GeneratedParser.CHAR -> DataType.CHAR()

partiql-spi/src/main/kotlin/org/partiql/spi/catalog/Identifier.kt

@@ -15,7 +15,8 @@ public class Identifier private constructor(
 ) : Iterable<Identifier.Simple> {
 
     /**
-     * Returns the unqualified name part.
+     * Returns the right-most simple identifier of the qualified identifier. For example, for an identifier
+     * a.b.c this method would return c.
      */
     public fun getIdentifier(): Simple = identifier
 

partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnDivide.kt

@@ -5,6 +5,7 @@ package org.partiql.spi.function.builtins
 
 import org.partiql.spi.function.Function
 import org.partiql.spi.function.builtins.internal.PErrors
+import org.partiql.spi.internal.isZero
 import org.partiql.spi.types.PType
 import org.partiql.spi.value.Datum
 import java.math.RoundingMode
@@ -72,6 +73,9 @@ internal object FnDivide : DiadicArithmeticOperator("divide") {
         return basic(PType.numeric(p, s), numericLhs, numericRhs) { args ->
             val arg0 = args[0].bigDecimal
             val arg1 = args[1].bigDecimal
+            if (arg1.isZero()) {
+                throw PErrors.divisionByZeroException(arg0, PType.numeric(p, s))
+            }
             val result = arg0.divide(arg1, s, RoundingMode.HALF_UP)
             Datum.numeric(result, p, s)
         }
@@ -82,6 +86,9 @@ internal object FnDivide : DiadicArithmeticOperator("divide") {
         return basic(PType.decimal(p, s), decimalLhs, decimalRhs) { args ->
             val arg0 = args[0].bigDecimal
             val arg1 = args[1].bigDecimal
+            if (arg1.isZero()) {
+                throw PErrors.divisionByZeroException(arg0, PType.decimal(p, s))
+            }
             val result = arg0.divide(arg1, s, RoundingMode.HALF_UP)
             Datum.decimal(result, p, s)
         }
@@ -105,6 +112,9 @@ internal object FnDivide : DiadicArithmeticOperator("divide") {
         return basic(PType.real()) { args ->
             val arg0 = args[0].float
             val arg1 = args[1].float
+            if (arg1.isZero()) {
+                throw PErrors.divisionByZeroException(arg0, PType.real())
+            }
             Datum.real(arg0 / arg1)
         }
     }
@@ -113,6 +123,9 @@ internal object FnDivide : DiadicArithmeticOperator("divide") {
         return basic(PType.doublePrecision()) { args ->
             val arg0 = args[0].double
             val arg1 = args[1].double
+            if (arg1.isZero()) {
+                throw PErrors.divisionByZeroException(arg0, PType.doublePrecision())
+            }
             Datum.doublePrecision(arg0 / arg1)
         }
     }

partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnModulo.kt

@@ -5,6 +5,7 @@ package org.partiql.spi.function.builtins
 
 import org.partiql.spi.function.Function
 import org.partiql.spi.function.builtins.internal.PErrors
+import org.partiql.spi.internal.isZero
 import org.partiql.spi.types.PType
 import org.partiql.spi.value.Datum
 
@@ -67,6 +68,9 @@ internal object FnModulo : DiadicArithmeticOperator("mod", false) {
         return basic(PType.numeric(p, s), numericLhs, numericRhs) { args ->
             val arg0 = args[0].bigDecimal
             val arg1 = args[1].bigDecimal
+            if (arg1.isZero()) {
+                throw PErrors.divisionByZeroException(arg0, PType.numeric(p, s))
+            }
             Datum.numeric(arg0 % arg1, p, s)
         }
     }
@@ -76,6 +80,9 @@ internal object FnModulo : DiadicArithmeticOperator("mod", false) {
         return basic(PType.decimal(p, s), decimalLhs, decimalRhs) { args ->
             val arg0 = args[0].bigDecimal
             val arg1 = args[1].bigDecimal
+            if (arg1.isZero()) {
+                throw PErrors.divisionByZeroException(arg0, PType.decimal(p, s))
+            }
             Datum.decimal(arg0 % arg1, p, s)
         }
     }
@@ -99,6 +106,9 @@ internal object FnModulo : DiadicArithmeticOperator("mod", false) {
         return basic(PType.real()) { args ->
             val arg0 = args[0].float
             val arg1 = args[1].float
+            if (arg1.isZero()) {
+                throw PErrors.divisionByZeroException(arg0, PType.real())
+            }
             Datum.real(arg0 % arg1)
         }
     }
@@ -107,6 +117,9 @@ internal object FnModulo : DiadicArithmeticOperator("mod", false) {
         return basic(PType.doublePrecision()) { args ->
             val arg0 = args[0].double
             val arg1 = args[1].double
+            if (arg1.isZero()) {
+                throw PErrors.divisionByZeroException(arg0, PType.doublePrecision())
+            }
             Datum.doublePrecision(arg0 % arg1)
         }
     }