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

689-696: Update getParquetExportCompressionLevel() to return 0 for LZ4_RAW.

The method returns 9 unconditionally, but the codec is now LZ4_RAW, which does not support compression levels (unlike ZSTD). This is inconsistent with PropServerConfiguration, which correctly defaults to 0 for non-ZSTD codecs, and with ExportModel.java, which explicitly treats LZ4_RAW as a codec that doesn't use compression level. The test expectations in ServerMainTest.java also confirm the compression level should be 0 for LZ4_RAW export.

Change line 695 to match the conditional logic used in PropServerConfiguration:

return parquetExportCompressionCodec == ParquetCompression.COMPRESSION_ZSTD ? 9 : 0;

Or, more directly, return 0 since the codec is fixed to LZ4_RAW at this configuration level.

core/rust/qdbr/src/parquet_write/fixed_len_bytes.rs (1)

68-82: Pass column.required through to bytes_to_page to avoid schema-encoding mismatch.

The Column.required field is available and correctly used for Symbol columns (line 765 in file.rs), but is not propagated to chunk_to_primitive_page or bytes_to_page. Since Long128, Uuid, and Long256 columns can be marked as required in the schema (via column_type_to_parquet_type), hardcoding required=false in build_plain_page creates a mismatch: the schema descriptor will advertise Repetition::Required while the page encoding includes definition levels and required=false. Update chunk_to_primitive_page to pass column.required, and refactor bytes_to_page to accept and use this flag to skip definition level encoding when appropriate.

core/rust/qdbr/src/parquet_write/varchar.rs (1)

232-277: Guard against usize overflow before unsafe bulk writes.

At Line 266 and Line 276, count * ENTRY_SIZE and base + ... can overflow, which would under-allocate and then write past the buffer inside the unsafe block. Add checked arithmetic and fail early.

✅ Suggested fix

         _ => {
             const ENTRY_SIZE: usize = 16; // 10 bytes header + 6 bytes offset
             let offset = data_mem.len();
             assert!(offset < VARCHAR_MAX_COLUMN_SIZE);

             let mut null_entry = [0u8; ENTRY_SIZE];
             null_entry[..10].copy_from_slice(&VARCHAR_HEADER_FLAG_NULL);
             null_entry[10..12].copy_from_slice(&(offset as u16).to_le_bytes());
             null_entry[12..16].copy_from_slice(&((offset >> 16) as u32).to_le_bytes());

             let base = aux_mem.len();
-            aux_mem.reserve(count * ENTRY_SIZE)?;
+            let total = count
+                .checked_mul(ENTRY_SIZE)
+                .ok_or_else(|| fmt_err!(OutOfBounds, "varchar null batch too large"))?;
+            let new_len = base
+                .checked_add(total)
+                .ok_or_else(|| fmt_err!(OutOfBounds, "varchar null batch too large"))?;
+            aux_mem.reserve(total)?;
             unsafe {
                 let ptr = aux_mem.as_mut_ptr().add(base);
                 for i in 0..count {
                     std::ptr::copy_nonoverlapping(
                         null_entry.as_ptr(),
                         ptr.add(i * ENTRY_SIZE),
                         ENTRY_SIZE,
                     );
                 }
-                aux_mem.set_len(base + count * ENTRY_SIZE);
+                aux_mem.set_len(new_len);
             }
             Ok(())
         }

core/rust/qdbr/src/parquet_write/symbol.rs (1)

159-221: Required fast‑path must exclude column_top/nulls.
If required is true while column_top > 0 or any value is -1, def levels are skipped and null_count remains 0, which corrupts page encoding (and non_null_len). Ensure required is only true when there are truly no nulls, or fall back to the optional path in those cases.

🐛 Suggested fix

-    let mut data_buffer = vec![];
+    let mut data_buffer = vec![];
+    let required_no_nulls = required && column_top == 0;
 
-    let definition_levels_byte_length = if required {
+    let definition_levels_byte_length = if required_no_nulls {
         0
     } else {
         // TODO(amunra): Optimize if there's no column top.
         let deflevels_iter = (0..num_rows).map(|i| {
             if i < column_top {
                 false
             } else {
                 let key = column_values[i - column_top];
                 // negative denotes a null value
                 if key > -1 {
                     true
                 } else {
                     null_count += 1;
                     false
                 }
             }
         });
         encode_primitive_def_levels(&mut data_buffer, deflevels_iter, num_rows, options.version)?;
         data_buffer.len()
     };
@@
-    let data_page = build_plain_page(
+    let data_page = build_plain_page(
         data_buffer,
         num_rows,
         null_count,
         definition_levels_byte_length,
         if options.write_statistics {
             Some(stats.into_parquet_stats(null_count))
         } else {
             None
         },
         primitive_type,
         options,
         Encoding::RleDictionary,
-        required,
+        required_no_nulls,
     )?;

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

126-135: Guard cache against addressCache changes: buffers with the same frameIndex across different parquet files will cause stale data reuse.

The cacheHit mechanism is keyed only by frameIndex. When PageFrameMemoryPool.of() switches to a new PageFrameAddressCache, it frees the parquetDecoder but does not clear cachedParquetBuffers. If the new addressCache has a frame with the same frameIndex as one cached from the previous addressCache, decode() will be skipped due to the cache hit, reusing buffers that contain data from the old parquet file.

Pools are reused across different addressCache instances (visible in TimeFrameCursorImpl, LatestByTask, PageFrameReduceTask), making frameIndex collisions possible. Add releaseParquetBuffers() call in PageFrameMemoryPool.of() to clear stale buffers when switching addressCache, or call it when parquetDecoder switches files in openParquet().

🧹 Suggested fix

     public void of(PageFrameAddressCache addressCache) {
         this.addressCache = addressCache;
         frameMemory.clear();
+        releaseParquetBuffers();
         Misc.free(parquetDecoder);
     }

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

1469-1502: Mask the high-bit nullability flag before any ColumnType operations—this is a critical bug.

Lines 1470–1473 set encodeColumnType |= 1 << 31 for symbol columns with no nulls, making the stored type negative. However, PartitionDecoder.getColumnType() (line 350–351) returns this raw int without masking, and the decoder immediately passes it to ColumnType.isSymbol(), ColumnType.isUndefined(), etc. (lines 298–303) which use direct equality checks.

When the high bit is set, these equality checks fail. For example, SYMBOL (20) | (1 << 31) = -2147483628, and -2147483628 == 20 is false, so the decoder misidentifies symbol columns with no nulls as undefined or fails type validation.

The fix requires masking the high bit before any ColumnType.*() call. Apply columnType & 0x7FFFFFFF in PartitionDecoder.getColumnType() or immediately after calling it in the decoder loop.

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

1469-1502: Symbol type classification fails in PartitionDecoder for non-nullable symbols.

The encoding in TableWriter.java:1472 sets Integer.MIN_VALUE on symbol types lacking null values. However, PartitionDecoder.copyToSansUnsupported() calls ColumnType.isSymbol(columnType) without masking (line 303), and ColumnType.isSymbol() performs direct equality: columnType == SYMBOL. When the flag is set, a symbol becomes negative (e.g., 0x80000000 | 12 = -2147483636), which fails the equality check and returns false. Lines 298 (isUndefined) and 319 (isTimestamp) have the same issue.

Apply the pattern shown in OwnedMemoryPartitionDescriptor.java:47: call ColumnType.tagOf(columnType) to strip the flag before any ColumnType API check:

// In PartitionDecoder.copyToSansUnsupported() around line 296-303
final int columnType = getColumnType(i);
final int taggedType = ColumnType.tagOf(columnType);

if (ColumnType.isUndefined(taggedType)) { ... }
if (ColumnType.isSymbol(taggedType)) { ... }
// and line 319: if (ColumnType.isTimestamp(taggedType) && ...)

This affects the TableWriter.convertPartitionNativeToParquet() flow at line 1683 where metadata is read from Parquet.

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

688-695: Fix compression level for LZ4_RAW codec.

Returning 9 is incorrect. LZ4_RAW does not support compression levels in the Parquet specification. The codebase itself confirms this: PropServerConfiguration uses level 0 as the default for LZ4_RAW (only ZSTD gets 9), ExportModel explicitly documents that LZ4_RAW doesn't use compression levels, and test expectations set this to 0. The partition encoder path correctly returns 0 for the same codec. Change this to return 0 to align with the codec and other configuration paths.

Proposed change

     `@Override`
     public int getParquetExportCompressionLevel() {
-        return 9;
+        return 0;
     }