Use true LE wire order for QWP decimals

The decimal encoder wrote multi-word values with the most
significant word first (hi, lo). This made the wire format
inconsistent: individual words were little-endian but word
order was big-endian.

QwpColumnWriter now emits words least-significant-first,
matching the byte-level little-endian convention used by all
other multi-word QWP types (UUID, LONG256). The test decoder
reversal and QwpConstants docs are updated to match.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: mtopolnik

core/src/main/java/io/questdb/client/cutlass/qwp/client/QwpColumnWriter.java

@@ -194,19 +194,19 @@ private void writeDecimal128Column(byte scale, long addr, int count) {
             long offset = (long) i * 16;
             long hi = Unsafe.getUnsafe().getLong(addr + offset);
             long lo = Unsafe.getUnsafe().getLong(addr + offset + 8);
-            buffer.putLong(hi);
             buffer.putLong(lo);
+            buffer.putLong(hi);
         }
     }
 
     private void writeDecimal256Column(byte scale, long addr, int count) {
         buffer.putByte(scale);
         for (int i = 0; i < count; i++) {
             long offset = (long) i * 32;
-            buffer.putLong(Unsafe.getUnsafe().getLong(addr + offset));
-            buffer.putLong(Unsafe.getUnsafe().getLong(addr + offset + 8));
-            buffer.putLong(Unsafe.getUnsafe().getLong(addr + offset + 16));
             buffer.putLong(Unsafe.getUnsafe().getLong(addr + offset + 24));
+            buffer.putLong(Unsafe.getUnsafe().getLong(addr + offset + 16));
+            buffer.putLong(Unsafe.getUnsafe().getLong(addr + offset + 8));
+            buffer.putLong(Unsafe.getUnsafe().getLong(addr + offset));
         }
     }
 

core/src/main/java/io/questdb/client/cutlass/qwp/protocol/QwpConstants.java

@@ -26,6 +26,10 @@
 
 /**
  * Constants for the QWP v1 binary protocol.
+ * <p>
+ * All little-endian encoding in this protocol is byte-level: multi-byte and
+ * multi-word values are stored with the least significant byte at the lowest
+ * address.
  */
 public final class QwpConstants {
 
@@ -160,18 +164,18 @@ public final class QwpConstants {
 
     /**
      * Column type: DECIMAL128 (16 bytes, 38 digits precision).
-     * Wire format: [scale (1B in schema)] + [big-endian unscaled value (16B)]
+     * Wire format: [scale (1B in schema)] + [little-endian unscaled value (16B)]
      */
     public static final byte TYPE_DECIMAL128 = 0x14;
     /**
      * Column type: DECIMAL256 (32 bytes, 77 digits precision).
-     * Wire format: [scale (1B in schema)] + [big-endian unscaled value (32B)]
+     * Wire format: [scale (1B in schema)] + [little-endian unscaled value (32B)]
      */
     public static final byte TYPE_DECIMAL256 = 0x15;
 
     /**
      * Column type: DECIMAL64 (8 bytes, 18 digits precision).
-     * Wire format: [scale (1B in schema)] + [big-endian unscaled value (8B)]
+     * Wire format: [scale (1B in schema)] + [little-endian unscaled value (8B)]
      */
     public static final byte TYPE_DECIMAL64 = 0x13;
     /**
@@ -200,7 +204,7 @@ public final class QwpConstants {
      */
     public static final byte TYPE_LONG = 0x05;
     /**
-     * Column type: LONG256 (32 bytes, big-endian).
+     * Column type: LONG256 (32 bytes, little-endian).
      */
     public static final byte TYPE_LONG256 = 0x0D;
 
@@ -232,7 +236,7 @@ public final class QwpConstants {
      */
     public static final byte TYPE_TIMESTAMP_NANOS = 0x10;
     /**
-     * Column type: UUID (16 bytes, big-endian).
+     * Column type: UUID (16 bytes, little-endian).
      */
     public static final byte TYPE_UUID = 0x0C;
 

core/src/test/java/io/questdb/client/test/cutlass/qwp/client/QwpUdpSenderTest.java

@@ -2224,7 +2224,7 @@ private void decodeDecimals(Object[] values, boolean[] nulls, int valueCount, in
                     values[row] = null;
                 } else {
                     byte[] bytes = reader.readBytes(width);
-                    // wire format is little-endian; BigInteger expects big-endian
+                    // LE wire format -> BE for BigInteger
                     for (int lo = 0, hi = bytes.length - 1; lo < hi; lo++, hi--) {
                         byte tmp = bytes[lo];
                         bytes[lo] = bytes[hi];