core/src/main/java/io/questdb/cairo/ColumnType.java (1)

211-221: Assert-only validation risks invalid array encodings in production

Both nDims bounds and element-type support checks are guarded by assertions. In production (asserts typically off), invalid values can slip through silently. Recommend adding fast runtime guards while keeping asserts for dev.

Apply this diff to add defensive checks without changing behavior for valid inputs:

-    public static int encodeArrayType(short elemType, int nDims, boolean checkSupportedElementTypes) {
-        assert nDims >= 1 && nDims <= ARRAY_NDIMS_LIMIT : "nDims out of range: " + nDims;
-        assert !checkSupportedElementTypes || (isSupportedArrayElementType(elemType) || elemType == UNDEFINED)
-                : "not supported as array element type: " + nameOf(elemType);
+    public static int encodeArrayType(short elemType, int nDims, boolean checkSupportedElementTypes) {
+        assert nDims >= 1 && nDims <= ARRAY_NDIMS_LIMIT : "nDims out of range: " + nDims;
+        if (nDims < 1 || nDims > ARRAY_NDIMS_LIMIT) {
+            throw CairoException.critical(0).put("nDims out of range: ").put(nDims);
+        }
+        assert !checkSupportedElementTypes || (isSupportedArrayElementType(elemType) || elemType == UNDEFINED)
+                : "not supported as array element type: " + nameOf(elemType);
+        if (checkSupportedElementTypes && !(isSupportedArrayElementType(elemType) || elemType == UNDEFINED)) {
+            throw CairoException.critical(0).put("not supported as array element type: ").put(nameOf(elemType));
+        }
         nDims--; // 0 == one dimension
         return (nDims & ARRAY_NDIMS_FIELD_MASK) << ARRAY_NDIMS_FIELD_POS
                 | (elemType & ARRAY_ELEMTYPE_FIELD_MASK) << ARRAY_ELEMTYPE_FIELD_POS
                 | ARRAY;
     }

core/src/main/java/io/questdb/cutlass/pgwire/PGOids.java (2)

250-273: Add PG_UUID → PG_ARR_UUID mapping in pgToArrayOid (PGOids.java)

Short: PGOids already defines PG_UUID and PG_ARR_UUID and PGPipelineEntry handles X_PG_ARR_UUID, but pgToArrayOid (core/src/main/java/io/questdb/cutlass/pgwire/PGOids.java) does not map PG_UUID. Add the case so typarray lookups (and PgTypeCatalogueCursor usage) advertise uuid[].

Files to touch

• core/src/main/java/io/questdb/cutlass/pgwire/PGOids.java — add PG_UUID case in pgToArrayOid (method around line ~250).
• core/src/main/java/io/questdb/griffin/engine/functions/catalogue/PgTypeCatalogueCursor.java — uses pgToArrayOid; will then report uuid[].
• core/src/main/java/io/questdb/cutlass/pgwire/PGPipelineEntry.java — already handles X_PG_ARR_UUID, no change needed.

Suggested diff

             case PG_VARCHAR:
                 return PG_ARR_VARCHAR;
+            case PG_UUID:
+                return PG_ARR_UUID;
             default:
                 return 0;

Note: Leave DATE unmapped in pgToArrayOid (QuestDB intentionally maps ColumnType.DATE to TIMESTAMP elsewhere).

---

231-240: pgArrayToElementType should mirror pgToArrayOid (add missing array→element mappings)

pgToArrayOid returns array OIDs for BOOL, INT2, INT4, INT8, FLOAT4, FLOAT8, TIMESTAMP, TIMESTAMPTZ, VARCHAR, but pgArrayToElementType currently only recognizes FLOAT8[] and INT8[]. This asymmetry can break array detection (see PgTypeCatalogueCursor, PGPipelineEntry, PGNonNullBinaryArrayView).

• Fix: update core/src/main/java/io/questdb/cutlass/pgwire/PGOids.java -> pgArrayToElementType to include the missing cases:

     public static int pgArrayToElementType(int pgOid) {
         switch (pgOid) {
+            case PG_ARR_BOOL:
+                return PG_BOOL;
+            case PG_ARR_INT2:
+                return PG_INT2;
+            case PG_ARR_INT4:
+                return PG_INT4;
             case PG_ARR_FLOAT8:
                 return PG_FLOAT8;
+            case PG_ARR_FLOAT4:
+                return PG_FLOAT4;
             case PG_ARR_INT8:
                 return PG_INT8;
+            case PG_ARR_TIMESTAMP:
+                return PG_TIMESTAMP;
+            case PG_ARR_TIMESTAMP_TZ:
+                return PG_TIMESTAMP_TZ;
+            case PG_ARR_VARCHAR:
+                return PG_VARCHAR;
             default:
                 return 0;
         }
     }

If the restriction to FLOAT8[] and INT8[] is intentional (only those arrays are expected in binary), please add a clarifying comment in the method instead of widening the mapping.

core/src/main/java/io/questdb/cutlass/pgwire/PGPipelineEntry.java (1)

1312-1347: Comprehensive array bind-type definitions: good coverage, consider small cleanup

• Additions for BOOL, UUID, BYTEA, (VAR)CHAR, INT2/4/8, FLOAT4/8, DATE arrays are clear and consistent.
• Minor nit: these cases duplicate encodeArrayType(elem, 1, false). Consider a small helper to reduce repetition if you touch this again.

core/src/main/java/io/questdb/cairo/ColumnType.java (1)

516-527: Registering all N-D array names irrespective of support can mislead users

This method registers array type names for all dimensions and for any base type passed in, while calling encodeArrayType(..., false) to bypass support checks. Given arrayTypeSet currently contains only a subset (e.g., DOUBLE), users can successfully reference names like "uuid[][]" that later fail at binding/casting.

• Either gate registration by support (for storage and/or PG semantics), or
• Keep the names but ensure any unsupported use fails with a precise, early error (ideally at parse time), and document the intent.

If you want to avoid surfacing unsupported multi-dimensional arrays for now, minimally constrain registration to 1-D for non-supported element types:

-        for (int d = 1; d <= ARRAY_NDIMS_LIMIT; d++) {
+        final boolean supported = isSupportedArrayElementType(type);
+        final int maxDims = supported ? ARRAY_NDIMS_LIMIT : 1;
+        for (int d = 1; d <= maxDims; d++) {
             sink.put("[]");
             int arrayType = encodeArrayType(type, d, false);
             String name = sink.toString();
             typeNameMap.put(arrayType, name);
             nameTypeMap.put(name, arrayType);
         }

Please confirm the intended scope: should multi-dimensional arrays be surfaced for all element types at the type-name level today, or only for element types that are actually supported in bindings/columns?

core/src/main/java/io/questdb/cutlass/pgwire/PGOids.java (2)

107-141: Reduce boilerplate for swapped OID constants

These X_PG_* and X_PG_ARR_* constants are a straightforward byte swap. Consider extracting a private static helper to compute swapped OIDs to avoid duplication and maintenance burden.

Example:

private static int x(int oid) {
    return ((oid >> 24) & 0xff) | ((oid << 8) & 0xff0000) | ((oid >> 8) & 0xff00) | ((oid << 24) & 0xff000000);
}

Then: public static final int X_PG_ARR_BOOL = x(PG_ARR_BOOL); etc.

---

321-323: TYPE_ARR_OIDS only maps DOUBLE[] and LONG[]; align with exposed capabilities

Despite the broadened OID catalog, only DOUBLE and LONG have array OID mappings here. If the intent is to support additional array element types over PG wire soon (e.g., INT4[] or VARCHAR[]), add their mappings when ready. Otherwise, document this limitation to avoid confusion.

Would you like a follow-up patch that:

• Adds mappings for other safe/practical element types, and
• Synchronizes ColumnType.arrayTypeSet accordingly?

Configuration used: .coderabbit.yaml
Review profile: CHILL
Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these settings in your CodeRabbit configuration.

core/src/main/java/io/questdb/griffin/SqlCodeGenerator.java (1)

2225-2255: Replace asserts with runtime guards and enrich array-cast error messages.

Asserts can be disabled in production. If non‑DOUBLE arrays reach this path, DOUBLE‑specific cast funcs may be constructed, risking incorrect behavior. Guard at runtime and include dimensionality in errors.

Apply this diff:

-                                assert ColumnType.decodeArrayElementType(fromType) == DOUBLE;
-                                assert ColumnType.decodeArrayElementType(toType) == DOUBLE;
+                                if (ColumnType.decodeArrayElementType(fromType) != DOUBLE
+                                        || ColumnType.decodeArrayElementType(toType) != DOUBLE) {
+                                    throw SqlException.unsupportedCast(
+                                            modelPosition,
+                                            castFromMetadata.getColumnName(i),
+                                            fromType,
+                                            toType
+                                    );
+                                }
@@
-                                final int fromDims = ColumnType.decodeArrayDimensionality(fromType);
-                                final int toDims = ColumnType.decodeArrayDimensionality(toType);
-                                if (toDims == -1) {
-                                    throw SqlException.$(modelPosition, "cast to array bind variable type is not supported [column=")
-                                            .put(castFromMetadata.getColumnName(i)).put(']');
-                                }
+                                final int fromDims = ColumnType.decodeArrayDimensionality(fromType);
+                                final int toDims = ColumnType.decodeArrayDimensionality(toType);
+                                if (toDims == -1) {
+                                    throw SqlException.$(modelPosition, "cast to array bind variable type is not supported [column=")
+                                            .put(castFromMetadata.getColumnName(i))
+                                            .put(", toDims=").put(toDims).put(']');
+                                }
@@
-                                    if (fromDims > toDims) {
-                                        throw SqlException.$(modelPosition, "array cast to lower dimensionality is not supported [column=")
-                                                .put(castFromMetadata.getColumnName(i)).put(']');
-                                    }
+                                    if (fromDims > toDims) {
+                                        throw SqlException.$(modelPosition, "array cast to lower dimensionality is not supported [column=")
+                                                .put(castFromMetadata.getColumnName(i))
+                                                .put(", fromDims=").put(fromDims)
+                                                .put(", toDims=").put(toDims).put(']');
+                                    }
@@
-                                assert ColumnType.decodeArrayElementType(toType) == DOUBLE;
-                                final int dims = ColumnType.decodeArrayDimensionality(toType);
-                                if (dims == -1) {
-                                    throw SqlException.$(modelPosition, "cast to array bind variable type is not supported [column=")
-                                            .put(castFromMetadata.getColumnName(i)).put(']');
-                                }
+                                if (ColumnType.decodeArrayElementType(toType) != DOUBLE) {
+                                    throw SqlException.unsupportedCast(
+                                            modelPosition,
+                                            castFromMetadata.getColumnName(i),
+                                            fromType,
+                                            toType
+                                    );
+                                }
+                                final int dims = ColumnType.decodeArrayDimensionality(toType);
+                                if (dims == -1) {
+                                    throw SqlException.$(modelPosition, "cast to array bind variable type is not supported [column=")
+                                            .put(castFromMetadata.getColumnName(i))
+                                            .put(", toDims=").put(dims).put(']');
+                                }

core/src/main/java/io/questdb/cairo/ColumnType.java (1)

759-771: Revisit LONG[] runtime support alignment.

arrayTypeSet includes DOUBLE only; PG wire appears to map INT8[] (LONG[]) too in this PR. If LONG[] is intended to be supported end‑to‑end, add LONG here; otherwise confirm PG path rejects it consistently.

#!/bin/bash
set -euo pipefail
# Check runtime support set
rg -n 'arrayTypeSet\.add\(' core/src/main/java/io/questdb/cairo/ColumnType.java -n
# Check PG OID mapping for INT8[]
rg -nP 'ARR.*(INT8|BIGINT)|PG_ARR_INT8|INT8\[\]' -n core/src/main/java

core/src/main/java/io/questdb/cutlass/line/tcp/ArrayBinaryFormatParser.java (1)

89-92: nDims read as unsigned: LGTM.

This fixes spurious negatives from Unsafe.getByte.

Ensure a test exists for nDims=0xFF → ARRAY_TOO_MANY_DIMENSIONS:

#!/bin/bash
set -euo pipefail
rg -n 'ARRAY_TOO_MANY_DIMENSIONS|tooManyDims\(\)' core/src/test -C2

core/src/main/java/io/questdb/griffin/engine/functions/finance/LevelTwoPriceArrayFunctionFactory.java (2)

101-107: Guard non‑positive targets (t <= 0).

Prevents nonsensical pricing when target is zero/negative and avoids corner path returning the first price for t == 0.

Apply:

         @Override
         public double getDouble(Record rec) {
             final double t = targetArg.getDouble(rec);
+            if (!(t > 0)) {
+                return Double.NaN;
+            }
             final ArrayView pricesArr = pricesArg.getArray(rec);
             final ArrayView sizesArr = sizesArg.getArray(rec);
             if (pricesArr.isNull() || sizesArr.isNull()) {
                 return Double.NaN;
             }

---

110-112: Make the length‑mismatch error more actionable.

Include actual lengths to speed up debugging.

Apply:

-                throw CairoException.nonCritical().position(sizesArgPos)
-                        .put("prices array length doesn't match sizes array length");
+                throw CairoException.nonCritical().position(sizesArgPos)
+                        .put("prices array length (").put(len)
+                        .put(") doesn't match sizes array length (")
+                        .put(sizesArr.getDimLen(0)).put(')');

core/src/main/java/io/questdb/griffin/SqlCodeGenerator.java (1)

835-847: Add column context when UNION type widening fails due to array bind vars.

getUnionCastType now throws, but the error surfaces without column info. Catch here and rethrow with the offending column name for better diagnostics.

Apply this diff:

-        for (int i = 0; i < columnCount; i++) {
-            int typeA = typesA.getColumnType(i);
-            int typeB = typesB.getColumnType(i);
-            int targetType = getUnionCastType(typeA, typeB);
-            metadata.add(new TableColumnMetadata(typesA.getColumnName(i), targetType));
-        }
+        for (int i = 0; i < columnCount; i++) {
+            final int typeA = typesA.getColumnType(i);
+            final int typeB = typesB.getColumnType(i);
+            final int targetType;
+            try {
+                targetType = getUnionCastType(typeA, typeB);
+            } catch (SqlException e) {
+                // Provide column context; position is unknown at this layer.
+                throw SqlException.$(0, "array bind variables are not supported in UNION queries [column=")
+                        .put(typesA.getColumnName(i)).put(']');
+            }
+            metadata.add(new TableColumnMetadata(typesA.getColumnName(i), targetType));
+        }

core/src/main/java/io/questdb/cairo/ColumnType.java (3)

223-233: Avoid assert‑only validation for prod paths.

Asserts may be disabled; enforce checkSupportedElementTypes at runtime.

-        assert !checkSupportedElementTypes || (isSupportedArrayElementType(elemType) || elemType == UNDEFINED)
-                : "not supported as array element type: " + nameOf(elemType);
+        if (checkSupportedElementTypes && !isSupportedArrayElementType(elemType) && elemType != UNDEFINED) {
+            throw CairoException.critical(0)
+                    .put("not supported as array element type: ").put(nameOf(elemType));
+        }

---

545-556: Precomputed array names: consider masking weak‑dims in nameOf for better diagnostics.

nameOf(ARRAY with weak‑dims) currently returns "unknown". Mask the flag so logs/errors show familiar names.

 public static String nameOf(int columnType) {
+        if (isArrayWithWeakDims(columnType)) {
+            columnType &= ~TYPE_FLAG_ARRAY_WEAK_DIMS;
+        }
         final int index = typeNameMap.keyIndex(columnType);
         if (index > -1) {
             return "unknown";
         }
         return typeNameMap.valueAtQuick(index);
 }

---

892-906: Array type names for many element types: add a clarifying comment.

Given only a subset is supported at runtime, add a one‑liner here stating these names are for error reporting/catalog friendliness.

-        addArrayTypeName(sink, ColumnType.BOOLEAN);
+        // Note: names registered below are for error messages/catalog; runtime support is limited by arrayTypeSet.
+        addArrayTypeName(sink, ColumnType.BOOLEAN);

core/src/main/java/io/questdb/cutlass/line/tcp/ArrayBinaryFormatParser.java (1)

76-86: Read elemType as unsigned for future‑proofing.

Current tags fit in < 64, but mask defensively to avoid sign extension if new tags exceed 127.

-                elemType = Unsafe.getUnsafe().getByte(addr);
+                elemType = (short) (Unsafe.getUnsafe().getByte(addr) & 0xFF);

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

Learnt from: mtopolnik
PR: questdb/questdb#5997
File: core/src/main/java/io/questdb/griffin/engine/functions/array/DoubleArrayAccessFunctionFactory.java:127-131
Timestamp: 2025-07-31T08:21:17.390Z
Learning: In DoubleArrayAccessFunctionFactory.java, overflow validation for array index casting from long to int is performed in the validateIndexArgs() method rather than at each individual cast site. The validateIndexArgs() method is called early in newInstance() to validate all index arguments, making subsequent casts safe.

Learnt from: jerrinot
PR: questdb/questdb#5996
File: core/src/test/java/io/questdb/test/cutlass/http/line/LineHttpSenderTest.java:350-356
Timestamp: 2025-08-04T09:16:27.366Z
Learning: In QuestDB ILP tests, maximum dimension values like `(1 << 28) - 1` are intentionally hard-coded instead of using constants like `ArrayView.DIM_MAX_LEN` to serve as "canaries" that will cause test failures if the API limits change, ensuring developers are aware of breaking changes to the ILP API.